@loro-dev/flock-wasm 0.1.5 → 0.2.0

package/README.md

@@ -135,7 +135,6 @@ import {
   type VersionVector,
   type VersionVectorEntry,
   type ExportBundle,
-  type ImportReport,
   type ScanOptions,
   type ScanRow,
   type ScanBound,
@@ -613,27 +612,26 @@ const signed = await flock.exportJson({
 });
 ```
 
-#### `importJson(bundle: ExportBundle): ImportReport`
+#### `importJson(bundle: ExportBundle): void`
 
 Imports a JSON bundle, merging entries using LWW semantics.
 
 - **`bundle`**: An `ExportBundle` from `exportJson()`.
-- **Returns**: `ImportReport` with `{ accepted: number, skipped: Array<{ key, reason }> }`.
-- **`accepted` counts records processed**, not records that changed state. Re-importing the same bundle may still report a positive `accepted` count even though no state changed and no events are emitted. Do not use `accepted` as a reliable indicator of whether new data was applied — use event listeners for that.
-- **Events**: Emits event batches for newly accepted entries.
+- **Returns**: `void`.
+- **Events**: Emits event batches for newly applied entries.
 - **Effect on debounce**: If `autoDebounceCommit` is active, any pending local events are flushed before the import events are delivered.
 
-#### `importJson(options: ImportOptions): Promise<ImportReport>`
+#### `importJson(options: ImportOptions): Promise<void>`
 
 Imports with preprocessing hooks (async).
 
 - **`options.bundle`**: The export bundle.
 - **`options.hooks.preprocess`**: Async function `(context, payload) => ImportDecision` to validate each entry before import.
-- **Returns**: `Promise<ImportReport>`.
+- **Returns**: `Promise<void>`.
 - **Use case**: Validate signatures, check authorization, or reject untrusted entries.
 
 ```ts
-const report = await flock.importJson({
+await flock.importJson({
   bundle,
   hooks: {
     preprocess: async (ctx, payload) => {
@@ -644,15 +642,14 @@ const report = await flock.importJson({
     },
   },
 });
-console.log(report.skipped); // entries rejected by the hook
 ```
 
-#### `importJsonStr(bundle: string): ImportReport`
+#### `importJsonStr(bundle: string): void`
 
 Convenience method that parses a JSON string and imports it.
 
 - **`bundle`**: JSON string representation of an `ExportBundle`.
-- **Returns**: `ImportReport`.
+- **Returns**: `void`.
 - **Use case**: Import directly from a network response or file read without manual parsing.
 
 #### `kvToJson(): ExportBundle`
@@ -714,7 +711,7 @@ type ImportOptions = {
 - **`context`**: `{ key: KeyPart[], clock: EntryClock, raw: ExportRecord }`.
 - **`payload`**: `{ data?: Value, metadata?: MetadataMap }` — a cloned copy for inspection (not mutation).
 - **`ImportDecision`**: Return `{ accept: true }`, `{ accept: false, reason: string }`, or `void` (treated as accept).
-- **Behavior**: Called once per entry before import. Rejected entries are excluded from the merge and reported in `ImportReport.skipped`.
+- **Behavior**: Called once per entry before import. Rejected entries are excluded from the merge.
 - **Use case**: Validate signatures, enforce ACLs, or reject entries from untrusted peers.
 
 ---
@@ -937,12 +934,7 @@ type ExportBundle = {
   entries: Record<string, ExportRecord>;  // Key (stringified) → record
 };
 
-type ImportReport = {
-  accepted: number;                              // Number of entries processed (not necessarily changed)
-  skipped: Array<{ key: KeyPart[]; reason: string }>;  // Rejected entries with reasons
-};
 ```
-
 ### Hook Types
 
 ```ts
@@ -1084,8 +1076,7 @@ const bobVersion = bob.version();
 const delta = alice.exportJson(bobVersion);
 
 // Step 3: Bob imports the delta
-const report = bob.importJson(delta);
-console.log(`Imported ${report.accepted} new entries`);
+bob.importJson(delta);
 
 // Step 4: Reverse direction
 const aliceVersion = alice.version();

package/base64/flock_wasm.js

@@ -231,20 +231,20 @@ function getArrayU8FromWasm0(ptr, len) {
     return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
 }
 
-function _assertClass(instance, klass) {
-    if (!(instance instanceof klass)) {
-        throw new Error(`expected instance of ${klass.name}`);
-    }
-}
-
 function passArray8ToWasm0(arg, malloc) {
     const ptr = malloc(arg.length * 1, 1) >>> 0;
     getUint8ArrayMemory0().set(arg, ptr / 1);
     WASM_VECTOR_LEN = arg.length;
     return ptr;
 }
+
+function _assertClass(instance, klass) {
+    if (!(instance instanceof klass)) {
+        throw new Error(`expected instance of ${klass.name}`);
+    }
+}
 function __wbg_adapter_56(arg0, arg1, arg2) {
-    wasm.closure43_externref_shim(arg0, arg1, arg2);
+    wasm.closure32_externref_shim(arg0, arg1, arg2);
 }
 
 const RawFlockFinalization = (typeof FinalizationRegistry === 'undefined')
@@ -333,6 +333,17 @@ export class RawFlock {
         }
         return takeFromExternrefTable0(ret[0]);
     }
+    /**
+     * @param {Uint8Array} bytes
+     */
+    importFile(bytes) {
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.rawflock_importFile(this.__wbg_ptr, ptr0, len0);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
     /**
      * Imports a JSON bundle into this flock instance.
      *
@@ -340,22 +351,16 @@ export class RawFlock {
      *
      * * `bundle` - The export bundle to import
      *
-     * # Returns
-     *
-     * An import report containing counts of accepted and skipped entries.
-     *
      * # Errors
      *
      * Returns an error if the bundle is invalid or import fails.
      * @param {any} bundle
-     * @returns {any}
      */
     importJson(bundle) {
         const ret = wasm.rawflock_importJson(this.__wbg_ptr, bundle);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
         }
-        return takeFromExternrefTable0(ret[0]);
     }
     /**
      * Sets a new peer ID for this flock instance.
@@ -563,23 +568,17 @@ export class RawFlock {
      *
      * * `other` - The other flock instance to merge from
      *
-     * # Returns
-     *
-     * An import report containing counts of accepted and skipped entries.
-     *
      * # Errors
      *
      * Returns an error if the merge operation fails.
      * @param {RawFlock} other
-     * @returns {any}
      */
     merge(other) {
         _assertClass(other, RawFlock);
         const ret = wasm.rawflock_merge(this.__wbg_ptr, other.__wbg_ptr);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
         }
-        return takeFromExternrefTable0(ret[0]);
     }
     /**
      * Deletes the value at the specified key (creates a tombstone).
@@ -637,6 +636,13 @@ export class RawFlock {
         }
         return takeFromExternrefTable0(ret[0]);
     }
+    /**
+     * @returns {boolean}
+     */
+    isEmpty() {
+        const ret = wasm.rawflock_isEmpty(this.__wbg_ptr);
+        return ret !== 0;
+    }
     /**
      * Creates a new flock instance from a file bytes array.
      *
@@ -993,8 +999,8 @@ function __wbg_get_imports() {
         const ret = false;
         return ret;
     };
-    imports.wbg.__wbindgen_closure_wrapper303 = function(arg0, arg1, arg2) {
-        const ret = makeMutClosure(arg0, arg1, 44, __wbg_adapter_56);
+    imports.wbg.__wbindgen_closure_wrapper229 = function(arg0, arg1, arg2) {
+        const ret = makeMutClosure(arg0, arg1, 33, __wbg_adapter_56);
         return ret;
     };
     imports.wbg.__wbindgen_debug_string = function(arg0, arg1) {

package/base64/index.d.ts

@@ -67,13 +67,6 @@ export type ImportDecision = ImportAccept | ImportSkip | ImportPayload | void;
 export type ImportHooks = {
     preprocess?: (context: ImportHookContext, payload: ImportPayload) => MaybePromise<ImportDecision>;
 };
-export type ImportReport = {
-    accepted: number;
-    skipped: Array<{
-        key: KeyPart[];
-        reason: string;
-    }>;
-};
 export type PutPayload = ExportPayload;
 export type PutHookContext = {
     key: KeyPart[];
@@ -126,6 +119,7 @@ export declare class Flock {
     private static fromInner;
     static fromJson(bundle: ExportBundle, peerId: string): Flock;
     static fromFile(bytes: Uint8Array, peerId?: string): Flock;
+    isEmpty(): boolean;
     checkInvariants(): void;
     setPeerId(peerId: string): void;
     private putWithMetaInternal;
@@ -183,9 +177,10 @@ export declare class Flock {
     exportJson(options: ExportOptions): Promise<ExportBundle>;
     private importJsonInternal;
     private importJsonWithHooks;
-    importJson(bundle: ExportBundle): ImportReport;
-    importJson(options: ImportOptions): Promise<ImportReport>;
-    importJsonStr(bundle: string): ImportReport;
+    importJson(bundle: ExportBundle): void;
+    importJson(options: ImportOptions): Promise<void>;
+    importFile(bytes: Uint8Array): void;
+    importJsonStr(bundle: string): void;
     getMaxPhysicalTime(): number;
     peerId(): string;
     kvToJson(): ExportBundle;

package/base64/index.js

@@ -502,20 +502,6 @@ function normalizeImportDecision(decision) {
     }
     return { accept: true };
 }
-function decodeImportReport(raw) {
-    if (!raw || typeof raw !== "object") {
-        return { accepted: 0, skipped: [] };
-    }
-    const report = raw;
-    const accepted = typeof report.accepted === "number" ? report.accepted : 0;
-    const skippedRaw = Array.isArray(report.skipped) ? report.skipped : [];
-    const skipped = skippedRaw.map((entry) => {
-        const key = entry && Array.isArray(entry.key) ? entry.key : [];
-        const reason = entry && typeof entry.reason === "string" ? entry.reason : "unknown";
-        return { key, reason };
-    });
-    return { accepted, skipped };
-}
 function cloneBundle(bundle) {
     const next = { version: bundle.version, entries: {} };
     for (const [key, record] of Object.entries(bundle.entries)) {
@@ -576,6 +562,9 @@ export class Flock {
         const inner = RawFlock.fromFile(normalizePeerId(peerId), bytes);
         return Flock.fromInner(inner);
     }
+    isEmpty() {
+        return this.inner.isEmpty();
+    }
     checkInvariants() {
         void this.version();
         void this.inclusiveVersion();
@@ -647,7 +636,7 @@ export class Flock {
     }
     merge(other) {
         this.eventBatcher.beforeImport();
-        void this.inner.merge(other.inner);
+        this.inner.merge(other.inner);
     }
     /**
      * Returns the exclusive/visible version vector.
@@ -706,13 +695,11 @@ export class Flock {
     }
     importJsonInternal(bundle) {
         this.eventBatcher.beforeImport();
-        const report = this.inner.importJson(bundle);
-        return decodeImportReport(report);
+        this.inner.importJson(bundle);
     }
     async importJsonWithHooks(options) {
         const preprocess = options.hooks?.preprocess;
         const working = preprocess ? cloneBundle(options.bundle) : options.bundle;
-        const skippedByHooks = [];
         if (preprocess) {
             for (const key of Object.keys(working.entries)) {
                 const record = working.entries[key];
@@ -724,18 +711,13 @@ export class Flock {
                 const decision = await preprocess(context, clonePayload(basePayload));
                 const normalized = normalizeImportDecision(decision);
                 if (!normalized.accept) {
-                    skippedByHooks.push({ key: context.key, reason: normalized.reason });
                     delete working.entries[key];
                     continue;
                 }
                 working.entries[key] = buildRecord(record.c, basePayload);
             }
         }
-        const coreReport = this.importJsonInternal(working);
-        return {
-            accepted: coreReport.accepted,
-            skipped: skippedByHooks.concat(coreReport.skipped),
-        };
+        this.importJsonInternal(working);
     }
     importJson(arg) {
         if (isImportOptions(arg)) {
@@ -743,9 +725,13 @@ export class Flock {
         }
         return this.importJsonInternal(arg);
     }
+    importFile(bytes) {
+        this.eventBatcher.beforeImport();
+        this.inner.importFile(bytes);
+    }
     importJsonStr(bundle) {
         const parsed = JSON.parse(bundle);
-        return this.importJson(parsed);
+        this.importJson(parsed);
     }
     getMaxPhysicalTime() {
         return Number(this.inner.getMaxPhysicalTime());

package/base64/wasm.d.ts

@@ -2,6 +2,7 @@ export declare class RawFlock {
   constructor(peerId: string);
   static fromJson(bundle: unknown, peerId: string): RawFlock;
   static fromFile(peerId: string, bytes: Uint8Array): RawFlock;
+  isEmpty(): boolean;
   peerId(): string;
   setPeerId(peerId: string): void;
   getMaxPhysicalTime(): number;
@@ -21,8 +22,9 @@ export declare class RawFlock {
     pruneTombstonesBefore?: number,
     peerId?: string,
   ): unknown;
-  importJson(bundle: unknown): unknown;
-  merge(other: RawFlock): unknown;
+  importJson(bundle: unknown): void;
+  importFile(bytes: Uint8Array): void;
+  merge(other: RawFlock): void;
   version(): unknown;
   inclusiveVersion(): unknown;
   exportFile(): Uint8Array;