xitdb 0.1.0 → 0.2.0

package/dist/read-array-list.d.ts

@@ -0,0 +1,13 @@
+import { Slot } from './slot';
+import type { Slotted } from './slotted';
+import { ReadCursor, CursorIterator } from './read-cursor';
+export declare class ReadArrayList implements Slotted {
+    cursor: ReadCursor;
+    constructor(cursor: ReadCursor);
+    slot(): Slot;
+    count(): Promise<number>;
+    iterator(): CursorIterator;
+    [Symbol.asyncIterator](): AsyncIterator<ReadCursor>;
+    getCursor(index: number): Promise<ReadCursor | null>;
+    getSlot(index: number): Promise<Slot | null>;
+}

package/dist/read-counted-hash-map.d.ts

@@ -0,0 +1,7 @@
+import { ReadHashMap } from './read-hash-map';
+import { ReadCursor } from './read-cursor';
+export declare class ReadCountedHashMap extends ReadHashMap {
+    protected constructor();
+    static create(cursor: ReadCursor): Promise<ReadCountedHashMap>;
+    count(): Promise<number>;
+}

package/dist/read-counted-hash-set.d.ts

@@ -0,0 +1,7 @@
+import { ReadHashSet } from './read-hash-set';
+import { ReadCursor } from './read-cursor';
+export declare class ReadCountedHashSet extends ReadHashSet {
+    protected constructor();
+    static create(cursor: ReadCursor): Promise<ReadCountedHashSet>;
+    count(): Promise<number>;
+}

package/dist/read-cursor.d.ts

@@ -0,0 +1,57 @@
+import { Slot } from './slot';
+import { SlotPointer } from './slot-pointer';
+import type { Slotted } from './slotted';
+import { Database, type PathPart } from './database';
+import { Bytes } from './writeable-data';
+export declare class KeyValuePairCursor {
+    valueCursor: ReadCursor;
+    keyCursor: ReadCursor;
+    hash: Uint8Array;
+    constructor(valueCursor: ReadCursor, keyCursor: ReadCursor, hash: Uint8Array);
+}
+export declare class ReadCursor implements Slotted {
+    slotPtr: SlotPointer;
+    db: Database;
+    constructor(slotPtr: SlotPointer, db: Database);
+    slot(): Slot;
+    readPath(path: PathPart[]): Promise<ReadCursor | null>;
+    readPathSlot(path: PathPart[]): Promise<Slot | null>;
+    readUint(): number;
+    readInt(): number;
+    readFloat(): number;
+    readBytes(maxSizeMaybe?: number | null): Promise<Uint8Array>;
+    readBytesObject(maxSizeMaybe?: number | null): Promise<Bytes>;
+    readKeyValuePair(): Promise<KeyValuePairCursor>;
+    reader(): Promise<Reader>;
+    count(): Promise<number>;
+    [Symbol.asyncIterator](): AsyncIterator<ReadCursor>;
+    iterator(): CursorIterator;
+}
+export declare class Reader {
+    parent: ReadCursor;
+    size: number;
+    startPosition: number;
+    relativePosition: number;
+    constructor(parent: ReadCursor, size: number, startPosition: number, relativePosition: number);
+    read(buffer: Uint8Array): Promise<number>;
+    readFully(buffer: Uint8Array): Promise<void>;
+    readByte(): Promise<number>;
+    readShort(): Promise<number>;
+    readInt(): Promise<number>;
+    readLong(): Promise<number>;
+    seek(position: number): void;
+}
+export declare class CursorIterator {
+    cursor: ReadCursor;
+    size: number;
+    index: number;
+    private stack;
+    private nextCursorMaybe;
+    private initialized;
+    constructor(cursor: ReadCursor);
+    init(): Promise<void>;
+    private initStack;
+    hasNext(): Promise<boolean>;
+    next(): Promise<ReadCursor | null>;
+    private nextInternal;
+}

package/dist/read-hash-map.d.ts

@@ -0,0 +1,27 @@
+import { Slot } from './slot';
+import type { Slotted } from './slotted';
+import { ReadCursor, CursorIterator, KeyValuePairCursor } from './read-cursor';
+import { Bytes } from './writeable-data';
+export declare class ReadHashMap implements Slotted {
+    cursor: ReadCursor;
+    protected constructor();
+    static create(cursor: ReadCursor): Promise<ReadHashMap>;
+    slot(): Slot;
+    iterator(): CursorIterator;
+    [Symbol.asyncIterator](): AsyncIterator<ReadCursor>;
+    getCursorByString(key: string): Promise<ReadCursor | null>;
+    getSlotByString(key: string): Promise<Slot | null>;
+    getKeyCursorByString(key: string): Promise<ReadCursor | null>;
+    getKeySlotByString(key: string): Promise<Slot | null>;
+    getKeyValuePairByString(key: string): Promise<KeyValuePairCursor | null>;
+    getCursorByBytes(key: Bytes): Promise<ReadCursor | null>;
+    getSlotByBytes(key: Bytes): Promise<Slot | null>;
+    getKeyCursorByBytes(key: Bytes): Promise<ReadCursor | null>;
+    getKeySlotByBytes(key: Bytes): Promise<Slot | null>;
+    getKeyValuePairByBytes(key: Bytes): Promise<KeyValuePairCursor | null>;
+    getCursor(hash: Uint8Array): Promise<ReadCursor | null>;
+    getSlot(hash: Uint8Array): Promise<Slot | null>;
+    getKeyCursor(hash: Uint8Array): Promise<ReadCursor | null>;
+    getKeySlot(hash: Uint8Array): Promise<Slot | null>;
+    getKeyValuePair(hash: Uint8Array): Promise<KeyValuePairCursor | null>;
+}

package/dist/read-hash-set.d.ts

@@ -0,0 +1,18 @@
+import { Slot } from './slot';
+import type { Slotted } from './slotted';
+import { ReadCursor, CursorIterator } from './read-cursor';
+import { Bytes } from './writeable-data';
+export declare class ReadHashSet implements Slotted {
+    cursor: ReadCursor;
+    protected constructor();
+    static create(cursor: ReadCursor): Promise<ReadHashSet>;
+    slot(): Slot;
+    iterator(): CursorIterator;
+    [Symbol.asyncIterator](): AsyncIterator<ReadCursor>;
+    getCursorByString(key: string): Promise<ReadCursor | null>;
+    getSlotByString(key: string): Promise<Slot | null>;
+    getCursorByBytes(key: Bytes): Promise<ReadCursor | null>;
+    getSlotByBytes(key: Bytes): Promise<Slot | null>;
+    getCursor(hash: Uint8Array): Promise<ReadCursor | null>;
+    getSlot(hash: Uint8Array): Promise<Slot | null>;
+}

package/dist/read-linked-array-list.d.ts

@@ -0,0 +1,13 @@
+import { Slot } from './slot';
+import type { Slotted } from './slotted';
+import { ReadCursor, CursorIterator } from './read-cursor';
+export declare class ReadLinkedArrayList implements Slotted {
+    cursor: ReadCursor;
+    constructor(cursor: ReadCursor);
+    slot(): Slot;
+    count(): Promise<number>;
+    iterator(): CursorIterator;
+    [Symbol.asyncIterator](): AsyncIterator<ReadCursor>;
+    getCursor(index: number): Promise<ReadCursor | null>;
+    getSlot(index: number): Promise<Slot | null>;
+}

package/dist/slot-pointer.d.ts

@@ -0,0 +1,7 @@
+import { Slot } from './slot';
+export declare class SlotPointer {
+    readonly position: number | null;
+    readonly slot: Slot;
+    constructor(position: number | null, slot: Slot);
+    withSlot(slot: Slot): SlotPointer;
+}

package/dist/slot.d.ts

@@ -0,0 +1,15 @@
+import { Tag } from './tag';
+import type { WriteableData } from './writeable-data';
+export declare class Slot implements WriteableData {
+    static readonly LENGTH = 9;
+    readonly value: bigint;
+    readonly tag: Tag;
+    readonly full: boolean;
+    constructor(value?: number | bigint, tag?: Tag, full?: boolean);
+    withTag(tag: Tag): Slot;
+    withFull(full: boolean): Slot;
+    empty(): boolean;
+    toBytes(): Uint8Array;
+    static fromBytes(bytes: Uint8Array): Slot;
+    equals(other: Slot): boolean;
+}

package/{src/slotted.ts → dist/slotted.d.ts}

@@ -1,5 +1,4 @@
 import type { Slot } from './slot';
-
 export interface Slotted {
-  slot(): Slot;
+    slot(): Slot;
 }

package/dist/tag.d.ts

@@ -0,0 +1,17 @@
+export declare const enum Tag {
+    NONE = 0,
+    INDEX = 1,
+    ARRAY_LIST = 2,
+    LINKED_ARRAY_LIST = 3,
+    HASH_MAP = 4,
+    KV_PAIR = 5,
+    BYTES = 6,
+    SHORT_BYTES = 7,
+    UINT = 8,
+    INT = 9,
+    FLOAT = 10,
+    HASH_SET = 11,
+    COUNTED_HASH_MAP = 12,
+    COUNTED_HASH_SET = 13
+}
+export declare function tagValueOf(n: number): Tag;

package/dist/write-array-list.d.ts

@@ -0,0 +1,16 @@
+import { ReadArrayList } from './read-array-list';
+import { WriteCursor, WriteCursorIterator } from './write-cursor';
+import { type ContextFunction } from './database';
+import type { WriteableData } from './writeable-data';
+export declare class WriteArrayList extends ReadArrayList {
+    constructor(cursor: WriteCursor);
+    static create(cursor: WriteCursor): Promise<WriteArrayList>;
+    iterator(): WriteCursorIterator;
+    [Symbol.asyncIterator](): AsyncIterator<WriteCursor>;
+    put(index: number, data: WriteableData): Promise<void>;
+    putCursor(index: number): Promise<WriteCursor>;
+    append(data: WriteableData): Promise<void>;
+    appendCursor(): Promise<WriteCursor>;
+    appendContext(data: WriteableData | null, fn: ContextFunction): Promise<void>;
+    slice(size: number): Promise<void>;
+}

package/dist/write-counted-hash-map.d.ts

@@ -0,0 +1,7 @@
+import { WriteHashMap } from './write-hash-map';
+import { WriteCursor } from './write-cursor';
+export declare class WriteCountedHashMap extends WriteHashMap {
+    protected constructor();
+    static create(cursor: WriteCursor): Promise<WriteCountedHashMap>;
+    count(): Promise<number>;
+}

package/dist/write-counted-hash-set.d.ts

@@ -0,0 +1,7 @@
+import { WriteHashSet } from './write-hash-set';
+import { WriteCursor } from './write-cursor';
+export declare class WriteCountedHashSet extends WriteHashSet {
+    protected constructor();
+    static create(cursor: WriteCursor): Promise<WriteCountedHashSet>;
+    count(): Promise<number>;
+}

package/dist/write-cursor.d.ts

@@ -0,0 +1,36 @@
+import { Slot } from './slot';
+import { SlotPointer } from './slot-pointer';
+import { Database, type PathPart } from './database';
+import { ReadCursor, KeyValuePairCursor, CursorIterator } from './read-cursor';
+import type { WriteableData } from './writeable-data';
+export declare class WriteKeyValuePairCursor extends KeyValuePairCursor {
+    valueCursor: WriteCursor;
+    keyCursor: WriteCursor;
+    constructor(valueCursor: WriteCursor, keyCursor: WriteCursor, hash: Uint8Array);
+}
+export declare class WriteCursor extends ReadCursor {
+    constructor(slotPtr: SlotPointer, db: Database);
+    writePath(path: PathPart[]): Promise<WriteCursor>;
+    write(data: WriteableData | null): Promise<void>;
+    writeIfEmpty(data: WriteableData): Promise<void>;
+    readKeyValuePair(): Promise<WriteKeyValuePairCursor>;
+    writer(): Promise<Writer>;
+    [Symbol.asyncIterator](): AsyncIterator<WriteCursor>;
+    iterator(): WriteCursorIterator;
+}
+export declare class Writer {
+    parent: WriteCursor;
+    size: number;
+    slot: Slot;
+    startPosition: number;
+    relativePosition: number;
+    formatTag: Uint8Array | null;
+    constructor(parent: WriteCursor, size: number, slot: Slot, startPosition: number, relativePosition: number);
+    write(buffer: Uint8Array): Promise<void>;
+    finish(): Promise<void>;
+    seek(position: number): void;
+}
+export declare class WriteCursorIterator extends CursorIterator {
+    constructor(cursor: WriteCursor);
+    next(): Promise<WriteCursor | null>;
+}

package/dist/write-hash-map.d.ts

@@ -0,0 +1,25 @@
+import { ReadHashMap } from './read-hash-map';
+import { WriteCursor, WriteCursorIterator } from './write-cursor';
+import type { WriteableData } from './writeable-data';
+import { Bytes } from './writeable-data';
+export declare class WriteHashMap extends ReadHashMap {
+    protected constructor();
+    static create(cursor: WriteCursor): Promise<WriteHashMap>;
+    iterator(): WriteCursorIterator;
+    [Symbol.asyncIterator](): AsyncIterator<WriteCursor>;
+    putByString(key: string, data: WriteableData): Promise<void>;
+    putCursorByString(key: string): Promise<WriteCursor>;
+    putKeyByString(key: string, data: WriteableData): Promise<void>;
+    putKeyCursorByString(key: string): Promise<WriteCursor>;
+    removeByString(key: string): Promise<boolean>;
+    putByBytes(key: Bytes, data: WriteableData): Promise<void>;
+    putCursorByBytes(key: Bytes): Promise<WriteCursor>;
+    putKeyByBytes(key: Bytes, data: WriteableData): Promise<void>;
+    putKeyCursorByBytes(key: Bytes): Promise<WriteCursor>;
+    removeByBytes(key: Bytes): Promise<boolean>;
+    put(hash: Uint8Array, data: WriteableData): Promise<void>;
+    putCursor(hash: Uint8Array): Promise<WriteCursor>;
+    putKey(hash: Uint8Array, data: WriteableData): Promise<void>;
+    putKeyCursor(hash: Uint8Array): Promise<WriteCursor>;
+    remove(hash: Uint8Array): Promise<boolean>;
+}

package/dist/write-hash-set.d.ts

@@ -0,0 +1,19 @@
+import { ReadHashSet } from './read-hash-set';
+import { WriteCursor, WriteCursorIterator } from './write-cursor';
+import type { WriteableData } from './writeable-data';
+import { Bytes } from './writeable-data';
+export declare class WriteHashSet extends ReadHashSet {
+    protected constructor();
+    static create(cursor: WriteCursor): Promise<WriteHashSet>;
+    iterator(): WriteCursorIterator;
+    [Symbol.asyncIterator](): AsyncIterator<WriteCursor>;
+    putByString(key: string): Promise<void>;
+    putCursorByString(key: string): Promise<WriteCursor>;
+    removeByString(key: string): Promise<boolean>;
+    putByBytes(key: Bytes): Promise<void>;
+    putCursorByBytes(key: Bytes): Promise<WriteCursor>;
+    removeByBytes(key: Bytes): Promise<boolean>;
+    put(hash: Uint8Array, data: WriteableData): Promise<void>;
+    putCursor(hash: Uint8Array): Promise<WriteCursor>;
+    remove(hash: Uint8Array): Promise<boolean>;
+}

package/dist/write-linked-array-list.d.ts

@@ -0,0 +1,19 @@
+import { Slot } from './slot';
+import { ReadLinkedArrayList } from './read-linked-array-list';
+import { WriteCursor, WriteCursorIterator } from './write-cursor';
+import type { WriteableData } from './writeable-data';
+export declare class WriteLinkedArrayList extends ReadLinkedArrayList {
+    constructor(cursor: WriteCursor);
+    static create(cursor: WriteCursor): Promise<WriteLinkedArrayList>;
+    iterator(): WriteCursorIterator;
+    [Symbol.asyncIterator](): AsyncIterator<WriteCursor>;
+    put(index: number, data: WriteableData): Promise<void>;
+    putCursor(index: number): Promise<WriteCursor>;
+    append(data: WriteableData): Promise<void>;
+    appendCursor(): Promise<WriteCursor>;
+    slice(offset: number, size: number): Promise<void>;
+    concat(list: Slot): Promise<void>;
+    insert(index: number, data: WriteableData): Promise<void>;
+    insertCursor(index: number): Promise<WriteCursor>;
+    remove(index: number): Promise<void>;
+}

package/dist/writeable-data.d.ts

@@ -0,0 +1,20 @@
+export interface WriteableData {
+}
+export declare class Uint implements WriteableData {
+    readonly value: number;
+    constructor(value: number);
+}
+export declare class Int implements WriteableData {
+    readonly value: number;
+    constructor(value: number);
+}
+export declare class Float implements WriteableData {
+    readonly value: number;
+    constructor(value: number);
+}
+export declare class Bytes implements WriteableData {
+    readonly value: Uint8Array;
+    readonly formatTag: Uint8Array | null;
+    constructor(value: Uint8Array | string, formatTag?: Uint8Array | string | null);
+    isShort(): boolean;
+}

package/package.json

@@ -1,12 +1,23 @@
 {
   "name": "xitdb",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
   "scripts": {
     "build": "bun build ./src/index.ts --outdir ./dist --target bun",
     "build:types": "tsc --emitDeclarationOnly",
+    "prepublishOnly": "bun run build && bun run build:types",
     "test": "bun test",
     "typecheck": "tsc --noEmit"
   },

package/.claude/settings.local.json

@@ -1,9 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "Bash(bun test:*)",
-      "Bash(bun run tsc:*)",
-      "Bash(bunx tsc:*)"
-    ]
-  }
-}

package/bun.lock

@@ -1,24 +0,0 @@
-{
-  "lockfileVersion": 1,
-  "configVersion": 1,
-  "workspaces": {
-    "": {
-      "name": "xitdb",
-      "devDependencies": {
-        "@types/bun": "latest",
-        "typescript": "^5.3.0",
-      },
-    },
-  },
-  "packages": {
-    "@types/bun": ["@types/bun@1.3.6", "", { "dependencies": { "bun-types": "1.3.6" } }, "sha512-uWCv6FO/8LcpREhenN1d1b6fcspAB+cefwD7uti8C8VffIv0Um08TKMn98FynpTiU38+y2dUO55T11NgDt8VAA=="],
-
-    "@types/node": ["@types/node@25.0.9", "", { "dependencies": { "undici-types": "~7.16.0" } }, "sha512-/rpCXHlCWeqClNBwUhDcusJxXYDjZTyE8v5oTO7WbL8eij2nKhUeU89/6xgjU7N4/Vh3He0BtyhJdQbDyhiXAw=="],
-
-    "bun-types": ["bun-types@1.3.6", "", { "dependencies": { "@types/node": "*" } }, "sha512-OlFwHcnNV99r//9v5IIOgQ9Uk37gZqrNMCcqEaExdkVq3Avwqok1bJFmvGMCkCE0FqzdY8VMOZpfpR3lwI+CsQ=="],
-
-    "typescript": ["typescript@5.9.3", "", { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw=="],
-
-    "undici-types": ["undici-types@7.16.0", "", {}, "sha512-Zz+aZWSj8LE6zoxD+xrjh4VfkIG8Ya6LvYkZqtUQGJPZjYl53ypCaUwWqo7eI0x66KBGeRo+mlBEkMSeSZ38Nw=="],
-  }
-}

package/bunfig.toml

@@ -1 +0,0 @@
-# Bun configuration for xitdb-ts

package/example/README.md

@@ -1,46 +0,0 @@
-This is an example program that reads a xitdb file and prints out its most recent value (the last item of the top-level ArrayList). From the root of this repo, run:
-
-```
-bun run example/dump.ts tests/fixtures/test.db
-```
-
-...and it will print:
-
-```
-ArrayList[2]:
-    HashMap{7}:
-      (none):
-        LinkedArrayList[1]:
-          [0]:
-            "Wash the car"
-      (none):
-        HashSet{1}: ["a"]
-      (none):
-        ArrayList[2]:
-          [0]:
-            HashMap{2}:
-              (none):
-                26 (uint)
-              (none):
-                "Alice"
-          [1]:
-            HashMap{2}:
-              (none):
-                42 (uint)
-              (none):
-                "Bob"
-      (none):
-        "foo"
-      "fruits":
-        ArrayList[2]:
-          [0]:
-            "lemon"
-          [1]:
-            "pear"
-      (none):
-        CountedHashMap{1}:
-          "a":
-            2 (uint)
-      (none):
-        CountedHashSet{1}: ["a"]
-```