@automerge/sedimentree 0.4.0-alpha.0

package/dist/wasm_bindgen/nodejs/sedimentree_wasm.d.ts

@@ -0,0 +1,445 @@
+/* tslint:disable */
+/* eslint-disable */
+
+export interface SedimentreeStorage {
+    saveSedimentreeId(sedimentreeId: SedimentreeId): Promise<void>;
+    deleteSedimentreeId(sedimentreeId: SedimentreeId): Promise<void>;
+    loadAllSedimentreeIds(): Promise<SedimentreeId[]>;
+
+    // Compound storage for commits (signed data + blob stored together)
+    saveCommit(sedimentreeId: SedimentreeId, digest: Digest, signedCommit: SignedLooseCommit, blob: Uint8Array): Promise<void>;
+    loadCommit(sedimentreeId: SedimentreeId, digest: Digest): Promise<CommitWithBlob | null>;
+    listCommitDigests(sedimentreeId: SedimentreeId): Promise<Digest[]>;
+    loadAllCommits(sedimentreeId: SedimentreeId): Promise<CommitWithBlob[]>;
+    deleteCommit(sedimentreeId: SedimentreeId, digest: Digest): Promise<void>;
+    deleteAllCommits(sedimentreeId: SedimentreeId): Promise<void>;
+
+    // Compound storage for fragments (signed data + blob stored together)
+    saveFragment(sedimentreeId: SedimentreeId, digest: Digest, signedFragment: SignedFragment, blob: Uint8Array): Promise<void>;
+    loadFragment(sedimentreeId: SedimentreeId, digest: Digest): Promise<FragmentWithBlob | null>;
+    listFragmentDigests(sedimentreeId: SedimentreeId): Promise<Digest[]>;
+    loadAllFragments(sedimentreeId: SedimentreeId): Promise<FragmentWithBlob[]>;
+    deleteFragment(sedimentreeId: SedimentreeId, digest: Digest): Promise<void>;
+    deleteAllFragments(sedimentreeId: SedimentreeId): Promise<void>;
+}
+
+
+
+/**
+ * A Wasm wrapper around the [`BlobMeta`] type.
+ */
+export class BlobMeta {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Get the digest of the blob.
+     */
+    digest(): Digest;
+    /**
+     * Create a `BlobMeta` from a digest and size.
+     *
+     * This is useful for deserialization when the original blob is not available.
+     * Since this is manual, the caller must ensure the digest and size are correct.
+     */
+    static fromDigestSize(digest: Digest, size_bytes: bigint): BlobMeta;
+    /**
+     * Create a new `BlobMeta` from the given blob contents.
+     */
+    constructor(blob: Uint8Array);
+    /**
+     * Get the size of the blob in bytes.
+     */
+    readonly sizeBytes: bigint;
+}
+
+/**
+ * A commit stored with its associated blob.
+ */
+export class CommitWithBlob {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Upcasts; to the JS-import type for [`WasmCommitWithBlob`].
+     */
+    __wasm_refgen_toWasmCommitWithBlob(): CommitWithBlob;
+    /**
+     * Create a new commit with blob.
+     */
+    constructor(signed: SignedLooseCommit, blob: Uint8Array);
+    /**
+     * Get the blob.
+     */
+    readonly blob: Uint8Array;
+    /**
+     * Get the signed commit.
+     */
+    readonly signed: SignedLooseCommit;
+}
+
+/**
+ * A JavaScript wrapper around `Depth`.
+ */
+export class Depth {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Internal method for a hack crossing the JS boundary.
+     */
+    __subduction_castToDepth(): Depth;
+    /**
+     * Upcasts; to the JS-import type for [`WasmDepth`].
+     */
+    __wasm_refgen_toWasmDepth(): Depth;
+    /**
+     * Creates a new `WasmDepth` from a JavaScript value.
+     *
+     * # Errors
+     *
+     * Returns a `NotU32Error` if the JS value is not safely coercible to `u32`.
+     */
+    constructor(js_value: any);
+    /**
+     * The depth value as an integer.
+     */
+    readonly value: number;
+}
+
+/**
+ * A wrapper around digest bytes for use in JavaScript via wasm-bindgen.
+ *
+ * Since JavaScript doesn't have Rust's type system, this stores raw bytes
+ * and converts to/from typed `Digest<T>` at the Rust boundary.
+ */
+export class Digest {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Upcasts; to the JS-import type for [`WasmDigest`].
+     */
+    __wasm_refgen_toWasmDigest(): Digest;
+    /**
+     * Creates a new digest from its Base58 string representation.
+     *
+     * # Errors
+     *
+     * Returns a `WasmInvalidDigest` error if the string cannot be decoded or is not a valid digest.
+     */
+    static fromBase58(s: string): Digest;
+    /**
+     * Creates a new digest from its byte representation.
+     *
+     * # Errors
+     *
+     * Returns a `WasmValue` error if the byte slice is not a valid digest.
+     */
+    static fromBytes(bytes: Uint8Array): Digest;
+    /**
+     * Creates a new digest from its hexadecimal string representation.
+     *
+     * # Errors
+     *
+     * Returns a [`WasmInvalidDigest`] if the string is not a valid digest.
+     */
+    static fromHexString(s: string): Digest;
+    /**
+     * Creates a new digest from its byte representation.
+     *
+     * # Errors
+     *
+     * Returns a `WasmValue` error if the byte slice is not a valid digest.
+     */
+    constructor(bytes: Uint8Array);
+    /**
+     * Returns the byte representation of the digest.
+     */
+    toBytes(): Uint8Array;
+    /**
+     * Returns the hexadecimal string representation of the digest.
+     */
+    toHexString(): string;
+}
+
+/**
+ * A data fragment used in the Sedimentree system.
+ */
+export class Fragment {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Upcasts; to the JS-import type for [`WasmFragment`].
+     */
+    __wasm_refgen_toWasmFragment(): Fragment;
+    /**
+     * Create a new fragment from the given sedimentree ID, head, boundary, checkpoints, and blob metadata.
+     */
+    constructor(sedimentree_id: SedimentreeId, head: Digest, boundary: Digest[], checkpoints: Digest[], blob_meta: BlobMeta);
+    /**
+     * Get the blob metadata of the fragment.
+     */
+    readonly blobMeta: BlobMeta;
+    /**
+     * Get the boundary digests of the fragment.
+     */
+    readonly boundary: Digest[];
+    /**
+     * Get the head digest of the fragment.
+     */
+    readonly head: Digest;
+}
+
+/**
+ * A fragment stored with its associated blob.
+ */
+export class FragmentWithBlob {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Upcasts; to the JS-import type for [`WasmFragmentWithBlob`].
+     */
+    __wasm_refgen_toWasmFragmentWithBlob(): FragmentWithBlob;
+    /**
+     * Create a new fragment with blob.
+     */
+    constructor(signed: SignedFragment, blob: Uint8Array);
+    /**
+     * Get the blob.
+     */
+    readonly blob: Uint8Array;
+    /**
+     * Get the signed fragment.
+     */
+    readonly signed: SignedFragment;
+}
+
+export class FragmentsArray {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Upcasts; to the JS-import type for [`WasmFragmentsArray`].
+     */
+    __wasm_refgen_toWasmFragmentsArray(): FragmentsArray;
+}
+
+/**
+ * A Wasm wrapper around the [`LooseCommit`] type.
+ */
+export class LooseCommit {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Upcasts; to the JS-import type for [`WasmLooseCommit`].
+     */
+    __wasm_refgen_toWasmLooseCommit(): LooseCommit;
+    /**
+     * Create a new `LooseCommit` from the given sedimentree ID, parents, and blob metadata.
+     */
+    constructor(sedimentree_id: SedimentreeId, parents: Digest[], blob_meta: BlobMeta);
+    /**
+     * Get the blob metadata of the commit.
+     */
+    readonly blobMeta: BlobMeta;
+    /**
+     * Get the digest of the commit.
+     */
+    readonly digest: Digest;
+    /**
+     * Get the parent digests of the commit.
+     */
+    readonly parents: Digest[];
+}
+
+/**
+ * An in-memory storage implementation for use in tests and development.
+ *
+ * This wraps the core `MemoryStorage` and exposes it via the `SedimentreeStorage` interface.
+ */
+export class MemoryStorage {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Delete all commits for a sedimentree.
+     */
+    deleteAllCommits(sedimentree_id: SedimentreeId): Promise<any>;
+    /**
+     * Delete all fragments for a sedimentree.
+     */
+    deleteAllFragments(sedimentree_id: SedimentreeId): Promise<any>;
+    /**
+     * Delete a commit by digest.
+     */
+    deleteCommit(sedimentree_id: SedimentreeId, digest: Digest): Promise<any>;
+    /**
+     * Delete a fragment by digest.
+     */
+    deleteFragment(sedimentree_id: SedimentreeId, digest: Digest): Promise<any>;
+    /**
+     * Delete a sedimentree ID.
+     */
+    deleteSedimentreeId(sedimentree_id: SedimentreeId): Promise<any>;
+    /**
+     * List all commit digests for a sedimentree.
+     */
+    listCommitDigests(sedimentree_id: SedimentreeId): Promise<any>;
+    /**
+     * List all fragment digests for a sedimentree.
+     */
+    listFragmentDigests(sedimentree_id: SedimentreeId): Promise<any>;
+    /**
+     * Load all commits for a sedimentree, returning `CommitWithBlob[]`.
+     */
+    loadAllCommits(sedimentree_id: SedimentreeId): Promise<any>;
+    /**
+     * Load all fragments for a sedimentree, returning `FragmentWithBlob[]`.
+     */
+    loadAllFragments(sedimentree_id: SedimentreeId): Promise<any>;
+    /**
+     * Load all sedimentree IDs.
+     */
+    loadAllSedimentreeIds(): Promise<any>;
+    /**
+     * Load a commit by digest, returning `CommitWithBlob` or null.
+     */
+    loadCommit(sedimentree_id: SedimentreeId, digest: Digest): Promise<any>;
+    /**
+     * Load a fragment by digest, returning `FragmentWithBlob` or null.
+     */
+    loadFragment(sedimentree_id: SedimentreeId, digest: Digest): Promise<any>;
+    /**
+     * Create a new in-memory storage instance.
+     */
+    constructor();
+    /**
+     * Save a commit with its blob.
+     */
+    saveCommit(sedimentree_id: SedimentreeId, _digest: Digest, signed_commit: SignedLooseCommit, blob: Uint8Array): Promise<any>;
+    /**
+     * Save a fragment with its blob.
+     */
+    saveFragment(sedimentree_id: SedimentreeId, _digest: Digest, signed_fragment: SignedFragment, blob: Uint8Array): Promise<any>;
+    /**
+     * Save a sedimentree ID.
+     */
+    saveSedimentreeId(sedimentree_id: SedimentreeId): Promise<any>;
+}
+
+/**
+ * The main Sedimentree data structure.
+ */
+export class Sedimentree {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Create an empty Sedimentree.
+     */
+    static empty(): Sedimentree;
+    /**
+     * Create a new Sedimentree from fragments and loose commits.
+     */
+    constructor(fragments: Fragment[], commits: LooseCommit[]);
+}
+
+/**
+ * A Wasm wrapper around the [`SedimentreeId`] type.
+ */
+export class SedimentreeId {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Upcasts; to the JS-import type for [`WasmSedimentreeId`].
+     */
+    __wasm_refgen_toWasmSedimentreeId(): SedimentreeId;
+    /**
+     * Create an ID from a byte array.
+     *
+     * # Errors
+     *
+     * Returns `Not32Bytes` if the provided byte array is not exactly 32 bytes long.
+     */
+    static fromBytes(bytes: Uint8Array): SedimentreeId;
+    /**
+     * Returns the raw bytes of this ID.
+     */
+    toBytes(): Uint8Array;
+    /**
+     * Returns the string representation of the ID.
+     */
+    toString(): string;
+}
+
+export class SedimentreeIdsArray {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Upcasts; to the JS-import type for [`WasmSedimentreeIdsArray`].
+     */
+    __wasm_refgen_toWasmSedimentreeIdsArray(): SedimentreeIdsArray;
+}
+
+/**
+ * A Wasm wrapper around `Signed<Fragment>`.
+ */
+export class SignedFragment {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Upcasts; to the JS-import type for [`WasmSignedFragment`].
+     */
+    __wasm_refgen_toWasmSignedFragment(): SignedFragment;
+    /**
+     * Encode this signed fragment to raw bytes.
+     */
+    encode(): Uint8Array;
+    /**
+     * Decode a `SignedFragment` from raw bytes.
+     *
+     * # Errors
+     *
+     * Returns an error if the bytes are not a valid signed fragment.
+     */
+    static tryDecode(bytes: Uint8Array): SignedFragment;
+    /**
+     * Get the unsigned payload without re-verifying the signature.
+     *
+     * # Errors
+     *
+     * Returns an error if the payload cannot be decoded.
+     */
+    readonly payload: Fragment;
+}
+
+/**
+ * A Wasm wrapper around `Signed<LooseCommit>`.
+ */
+export class SignedLooseCommit {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Upcasts; to the JS-import type for [`WasmSignedLooseCommit`].
+     */
+    __wasm_refgen_toWasmSignedLooseCommit(): SignedLooseCommit;
+    /**
+     * Encode this signed loose commit to raw bytes.
+     */
+    encode(): Uint8Array;
+    /**
+     * Decode a `SignedLooseCommit` from raw bytes.
+     *
+     * # Errors
+     *
+     * Returns an error if the bytes are not a valid signed loose commit.
+     */
+    static tryDecode(bytes: Uint8Array): SignedLooseCommit;
+    /**
+     * Get the unsigned payload without re-verifying the signature.
+     *
+     * # Errors
+     *
+     * Returns an error if the payload cannot be decoded.
+     */
+    readonly payload: LooseCommit;
+}

package/dist/wasm_bindgen/nodejs/sedimentree_wasm_bg.wasm.d.ts

@@ -0,0 +1,90 @@
+/* tslint:disable */
+/* eslint-disable */
+export const memory: WebAssembly.Memory;
+export const __wbg_depth_free: (a: number, b: number) => void;
+export const depth_new: (a: number, b: number) => void;
+export const depth_value: (a: number) => number;
+export const depth___subduction_castToDepth: (a: number) => number;
+export const __wbg_digest_free: (a: number, b: number) => void;
+export const digest_new: (a: number, b: number, c: number) => void;
+export const digest_fromBytes: (a: number, b: number, c: number) => void;
+export const digest_fromBase58: (a: number, b: number, c: number) => void;
+export const digest_toBytes: (a: number, b: number) => void;
+export const digest_fromHexString: (a: number, b: number, c: number) => void;
+export const digest_toHexString: (a: number, b: number) => void;
+export const digest___wasm_refgen_toWasmDigest: (a: number) => number;
+export const __wbg_fragment_free: (a: number, b: number) => void;
+export const fragment_new: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => number;
+export const fragment_head: (a: number) => number;
+export const fragment_boundary: (a: number, b: number) => void;
+export const fragment_blobMeta: (a: number) => number;
+export const fragment___wasm_refgen_toWasmFragment: (a: number) => number;
+export const __wbg_fragmentsarray_free: (a: number, b: number) => void;
+export const fragmentsarray___wasm_refgen_toWasmFragmentsArray: (a: number) => number;
+export const fragmentwithblob_signed: (a: number) => number;
+export const fragmentwithblob___wasm_refgen_toWasmFragmentWithBlob: (a: number) => number;
+export const __wbg_loosecommit_free: (a: number, b: number) => void;
+export const loosecommit_new: (a: number, b: number, c: number, d: number) => number;
+export const loosecommit_digest: (a: number) => number;
+export const loosecommit_parents: (a: number, b: number) => void;
+export const loosecommit_blobMeta: (a: number) => number;
+export const loosecommit___wasm_refgen_toWasmLooseCommit: (a: number) => number;
+export const __wbg_blobmeta_free: (a: number, b: number) => void;
+export const blobmeta_new: (a: number, b: number) => number;
+export const blobmeta_fromDigestSize: (a: number, b: bigint) => number;
+export const blobmeta_digest: (a: number) => number;
+export const blobmeta_sizeBytes: (a: number) => bigint;
+export const __wbg_commitwithblob_free: (a: number, b: number) => void;
+export const commitwithblob_new: (a: number, b: number) => number;
+export const commitwithblob_signed: (a: number) => number;
+export const commitwithblob_blob: (a: number) => number;
+export const commitwithblob___wasm_refgen_toWasmCommitWithBlob: (a: number) => number;
+export const __wbg_sedimentree_free: (a: number, b: number) => void;
+export const sedimentree_new: (a: number, b: number, c: number, d: number) => number;
+export const sedimentree_empty: () => number;
+export const sedimentreeid_fromBytes: (a: number, b: number, c: number) => void;
+export const sedimentreeid_toString: (a: number, b: number) => void;
+export const __wbg_sedimentreeidsarray_free: (a: number, b: number) => void;
+export const sedimentreeidsarray___wasm_refgen_toWasmSedimentreeIdsArray: (a: number) => number;
+export const signedloosecommit_tryDecode: (a: number, b: number) => void;
+export const signedloosecommit_encode: (a: number) => number;
+export const signedloosecommit_payload: (a: number, b: number) => void;
+export const signedloosecommit___wasm_refgen_toWasmSignedLooseCommit: (a: number) => number;
+export const __wbg_signedfragment_free: (a: number, b: number) => void;
+export const signedfragment_tryDecode: (a: number, b: number) => void;
+export const signedfragment_encode: (a: number) => number;
+export const signedfragment_payload: (a: number, b: number) => void;
+export const signedfragment___wasm_refgen_toWasmSignedFragment: (a: number) => number;
+export const __wbg_memorystorage_free: (a: number, b: number) => void;
+export const memorystorage_new: () => number;
+export const memorystorage_saveSedimentreeId: (a: number, b: number) => number;
+export const memorystorage_deleteSedimentreeId: (a: number, b: number) => number;
+export const memorystorage_loadAllSedimentreeIds: (a: number) => number;
+export const memorystorage_saveCommit: (a: number, b: number, c: number, d: number, e: number) => number;
+export const memorystorage_loadCommit: (a: number, b: number, c: number) => number;
+export const memorystorage_listCommitDigests: (a: number, b: number) => number;
+export const memorystorage_loadAllCommits: (a: number, b: number) => number;
+export const memorystorage_deleteCommit: (a: number, b: number, c: number) => number;
+export const memorystorage_deleteAllCommits: (a: number, b: number) => number;
+export const memorystorage_saveFragment: (a: number, b: number, c: number, d: number, e: number) => number;
+export const memorystorage_loadFragment: (a: number, b: number, c: number) => number;
+export const memorystorage_listFragmentDigests: (a: number, b: number) => number;
+export const memorystorage_loadAllFragments: (a: number, b: number) => number;
+export const memorystorage_deleteFragment: (a: number, b: number, c: number) => number;
+export const memorystorage_deleteAllFragments: (a: number, b: number) => number;
+export const depth___wasm_refgen_toWasmDepth: (a: number) => number;
+export const fragmentwithblob_new: (a: number, b: number) => number;
+export const __wbg_sedimentreeid_free: (a: number, b: number) => void;
+export const __wbg_signedloosecommit_free: (a: number, b: number) => void;
+export const __wbg_fragmentwithblob_free: (a: number, b: number) => void;
+export const fragmentwithblob_blob: (a: number) => number;
+export const sedimentreeid___wasm_refgen_toWasmSedimentreeId: (a: number) => number;
+export const sedimentreeid_toBytes: (a: number, b: number) => void;
+export const __wasm_bindgen_func_elem_628: (a: number, b: number) => void;
+export const __wasm_bindgen_func_elem_1601: (a: number, b: number, c: number, d: number) => void;
+export const __wasm_bindgen_func_elem_1606: (a: number, b: number, c: number, d: number) => void;
+export const __wbindgen_export: (a: number) => void;
+export const __wbindgen_export2: (a: number, b: number) => number;
+export const __wbindgen_add_to_stack_pointer: (a: number) => number;
+export const __wbindgen_export3: (a: number, b: number, c: number, d: number) => number;
+export const __wbindgen_export4: (a: number, b: number, c: number) => void;

package/dist/wasm_bindgen/nodejs/snippets/sedimentree_wasm-02bbe03284226492/inline0.js

@@ -0,0 +1,2 @@
+
+    export function tryIntoJsFragmentArray(xs) { return xs; }

package/dist/wasm_bindgen/nodejs/snippets/sedimentree_wasm-02bbe03284226492/inline1.js

@@ -0,0 +1,2 @@
+
+export function tryIntoLooseCommitArray(xs) { return xs; }

package/dist/wasm_bindgen/nodejs/snippets/sedimentree_wasm-02bbe03284226492/inline2.js

@@ -0,0 +1,2 @@
+
+    export function tryIntoJsSedimentreeIdsArray(xs) { return xs; }