www/firefox: fix build on powerpc64

Workaround for https://bugzilla.mozilla.org/show_bug.cgi?id=1797714

3 files changed, 1468 insertions, 0 deletions

diff --git a/www/firefox/Makefile b/www/firefox/Makefile
index d3c5ab960939..248fe43f3950 100644
--- a/www/firefox/Makefile
+++ b/www/firefox/Makefile
@@ -66,6 +66,10 @@ post-patch:
 		${FIREFOX_DESKTOP}
 	@${REINPLACE_CMD} -e 's|%%LOCALBASE%%|${LOCALBASE}|g' \
 		${WRKSRC}/browser/app/nsBrowserApp.cpp
+.if ${ARCH} == powerpc64
+	@${CP} ${PATCHDIR}/RustTabs.jsm ${WRKSRC}/toolkit/components/uniffi-bindgen-gecko-js/components/generated/RustTabs.jsm
+	@${CP} ${PATCHDIR}/UniFFIGeneratedScaffolding.cpp ${WRKSRC}/toolkit/components/uniffi-js/UniFFIGeneratedScaffolding.cpp
+.endif
 
 post-install:
 	${INSTALL_DATA} ${FIREFOX_DESKTOP} ${STAGEDIR}${PREFIX}/share/applications/
diff --git a/www/firefox/files/RustTabs.jsm b/www/firefox/files/RustTabs.jsm
new file mode 100644
index 000000000000..95b1bd035b17
--- /dev/null
+++ b/www/firefox/files/RustTabs.jsm
@@ -0,0 +1,1181 @@
+// This file was autogenerated by the `uniffi-bindgen-gecko-js` crate.
+// Trust me, you don't want to mess with it!
+
+
+
+"use strict";
+
+var EXPORTED_SYMBOLS = [];
+
+// Write/Read data to/from an ArrayBuffer
+class ArrayBufferDataStream {
+    constructor(arrayBuffer) {
+        this.dataView = new DataView(arrayBuffer);
+        this.pos = 0;
+    }
+
+    readUint8() {
+        let rv = this.dataView.getUint8(this.pos);
+        this.pos += 1;
+        return rv;
+    }
+
+    writeUint8(value) {
+        this.dataView.setUint8(this.pos, value);
+        this.pos += 1;
+    }
+
+    readUint16() {
+        let rv = this.dataView.getUint16(this.pos);
+        this.pos += 2;
+        return rv;
+    }
+
+    writeUint16(value) {
+        this.dataView.setUint16(this.pos, value);
+        this.pos += 2;
+    }
+
+    readUint32() {
+        let rv = this.dataView.getUint32(this.pos);
+        this.pos += 4;
+        return rv;
+    }
+
+    writeUint32(value) {
+        this.dataView.setUint32(this.pos, value);
+        this.pos += 4;
+    }
+
+    readUint64() {
+        let rv = this.dataView.getBigUint64(this.pos);
+        this.pos += 8;
+        return Number(rv);
+    }
+
+    writeUint64(value) {
+        this.dataView.setBigUint64(this.pos, BigInt(value));
+        this.pos += 8;
+    }
+
+
+    readInt8() {
+        let rv = this.dataView.getInt8(this.pos);
+        this.pos += 1;
+        return rv;
+    }
+
+    writeInt8(value) {
+        this.dataView.setInt8(this.pos, value);
+        this.pos += 1;
+    }
+
+    readInt16() {
+        let rv = this.dataView.getInt16(this.pos);
+        this.pos += 2;
+        return rv;
+    }
+
+    writeInt16(value) {
+        this.dataView.setInt16(this.pos, value);
+        this.pos += 2;
+    }
+
+    readInt32() {
+        let rv = this.dataView.getInt32(this.pos);
+        this.pos += 4;
+        return rv;
+    }
+
+    writeInt32(value) {
+        this.dataView.setInt32(this.pos, value);
+        this.pos += 4;
+    }
+
+    readInt64() {
+        let rv = this.dataView.getBigInt64(this.pos);
+        this.pos += 8;
+        return Number(rv);
+    }
+
+    writeInt64(value) {
+        this.dataView.setBigInt64(this.pos, BigInt(value));
+        this.pos += 8;
+    }
+
+
+    readFloat32() {
+        let rv = this.dataView.getFloat32(this.pos);
+        this.pos += 4;
+        return rv;
+    }
+
+    writeFloat32(value) {
+        this.dataView.setFloat32(this.pos, value);
+        this.pos += 4;
+    }
+
+    readFloat64() {
+        let rv = this.dataView.getFloat64(this.pos);
+        this.pos += 8;
+        return rv;
+    }
+
+    writeFloat64(value) {
+        this.dataView.setFloat64(this.pos, value);
+        this.pos += 8;
+    }
+
+
+    writeString(value) {
+      const encoder = new TextEncoder();
+      // Note: in order to efficiently write this data, we first write the
+      // string data, reserving 4 bytes for the size.
+      const dest = new Uint8Array(this.dataView.buffer, this.pos + 4);
+      const encodeResult = encoder.encodeInto(value, dest);
+      if (encodeResult.read != value.length) {
+        throw new UniFFIError(
+            "writeString: out of space when writing to ArrayBuffer.  Did the computeSize() method returned the wrong result?"
+        );
+      }
+      const size = encodeResult.written;
+      // Next, go back and write the size before the string data
+      this.dataView.setUint32(this.pos, size);
+      // Finally, advance our position past both the size and string data
+      this.pos += size + 4;
+    }
+
+    readString() {
+      const decoder = new TextDecoder();
+      const size = this.readUint32();
+      const source = new Uint8Array(this.dataView.buffer, this.pos, size)
+      const value = decoder.decode(source);
+      this.pos += size;
+      return value;
+    }
+
+    // Reads a TabsStore pointer from the data stream
+    // UniFFI Pointers are **always** 8 bytes long. That is enforced
+    // by the C++ and Rust Scaffolding code.
+    readPointerTabsStore() {
+        const pointerId = 0; // tabs:TabsStore
+        const res = UniFFIScaffolding.readPointer(pointerId, this.dataView.buffer, this.pos);
+        this.pos += 8;
+        return res;
+    }
+
+    // Writes a TabsStore pointer into the data stream
+    // UniFFI Pointers are **always** 8 bytes long. That is enforced
+    // by the C++ and Rust Scaffolding code.
+    writePointerTabsStore(value) {
+        const pointerId = 0; // tabs:TabsStore
+        UniFFIScaffolding.writePointer(pointerId, value, this.dataView.buffer, this.pos);
+        this.pos += 8;
+    }
+    
+
+    // Reads a TabsBridgedEngine pointer from the data stream
+    // UniFFI Pointers are **always** 8 bytes long. That is enforced
+    // by the C++ and Rust Scaffolding code.
+    readPointerTabsBridgedEngine() {
+        const pointerId = 1; // tabs:TabsBridgedEngine
+        const res = UniFFIScaffolding.readPointer(pointerId, this.dataView.buffer, this.pos);
+        this.pos += 8;
+        return res;
+    }
+
+    // Writes a TabsBridgedEngine pointer into the data stream
+    // UniFFI Pointers are **always** 8 bytes long. That is enforced
+    // by the C++ and Rust Scaffolding code.
+    writePointerTabsBridgedEngine(value) {
+        const pointerId = 1; // tabs:TabsBridgedEngine
+        UniFFIScaffolding.writePointer(pointerId, value, this.dataView.buffer, this.pos);
+        this.pos += 8;
+    }
+    
+}
+
+function handleRustResult(result, liftCallback, liftErrCallback) {
+    switch (result.code) {
+        case "success":
+            return liftCallback(result.data);
+
+        case "error":
+            throw liftErrCallback(result.data);
+
+        case "internal-error":
+            let message = result.internalErrorMessage;
+            if (message) {
+                throw new UniFFIInternalError(message);
+            } else {
+                throw new UniFFIInternalError("Unknown error");
+            }
+
+        default:
+            throw new UniFFIError(`Unexpected status code: ${result.code}`);
+    }
+}
+
+class UniFFIError {
+    constructor(message) {
+        this.message = message;
+    }
+}
+
+class UniFFIInternalError extends UniFFIError {}
+
+// Base class for FFI converters
+class FfiConverter {
+    static checkType(name, value) {
+        if (value === undefined ) {
+            throw TypeError(`${name} is undefined`);
+        }
+        if (value === null ) {
+            throw TypeError(`${name} is null`);
+        }
+    }
+}
+
+// Base class for FFI converters that lift/lower by reading/writing to an ArrayBuffer
+class FfiConverterArrayBuffer extends FfiConverter {
+    static lift(buf) {
+        return this.read(new ArrayBufferDataStream(buf));
+    }
+
+    static lower(value) {
+        const buf = new ArrayBuffer(this.computeSize(value));
+        const dataStream = new ArrayBufferDataStream(buf);
+        this.write(dataStream, value);
+        return buf;
+    }
+}
+
+// Symbols that are used to ensure that Object constructors
+// can only be used with a proper UniFFI pointer
+const uniffiObjectPtr = Symbol("uniffiObjectPtr");
+const constructUniffiObject = Symbol("constructUniffiObject");
+
+class FfiConverterI64 extends FfiConverter {
+    static checkType(name, value) {
+        super.checkType(name, value);
+        if (!Number.isSafeInteger(value)) {
+            throw TypeError(`${name} exceeds the safe integer bounds (${value})`);
+        }
+    }
+    static computeSize() {
+        return 8;
+    }
+    static lift(value) {
+        return value;
+    }
+    static lower(value) {
+        return value;
+    }
+    static write(dataStream, value) {
+        dataStream.writeInt64(value)
+    }
+    static read(dataStream) {
+        return dataStream.readInt64()
+    }
+}
+
+// Export the FFIConverter object to make external types work.
+EXPORTED_SYMBOLS.push("FfiConverterI64");
+
+class FfiConverterString extends FfiConverter {
+    static lift(buf) {
+        const decoder = new TextDecoder();
+        const utf8Arr = new Uint8Array(buf);
+        return decoder.decode(utf8Arr);
+    }
+    static lower(value) {
+        const encoder = new TextEncoder();
+        return encoder.encode(value).buffer;
+    }
+
+    static write(dataStream, value) {
+        dataStream.writeString(value);
+    }
+
+    static read(dataStream) {
+        return dataStream.readString();
+    }
+
+    static computeSize(value) {
+        const encoder = new TextEncoder();
+        return 4 + encoder.encode(value).length
+    }
+}
+
+// Export the FFIConverter object to make external types work.
+EXPORTED_SYMBOLS.push("FfiConverterString");
+
+class TabsBridgedEngine {
+    // Use `init` to instantiate this class.
+    // DO NOT USE THIS CONSTRUCTOR DIRECTLY
+    constructor(opts) {
+        if (!Object.prototype.hasOwnProperty.call(opts, constructUniffiObject)) {
+            throw new UniFFIError("Attempting to construct an object using the JavaScript constructor directly" +
+            "Please use a UDL defined constructor, or the init function for the primary constructor")
+        }
+        if (!opts[constructUniffiObject] instanceof UniFFIPointer) {
+            throw new UniFFIError("Attempting to create a UniFFI object with a pointer that is not an instance of UniFFIPointer")
+        }
+        this[uniffiObjectPtr] = opts[constructUniffiObject];
+    }
+    lastSync() {
+    const liftResult = (result) => FfiConverterI64.lift(result);
+    const liftError = (data) => FfiConverterTypeTabsError.lift(data);
+    const functionCall = () => {
+        return UniFFIScaffolding.callAsync(
+            7, // tabs:tabs_af8e_TabsBridgedEngine_last_sync
+            FfiConverterTypeTabsBridgedEngine.lower(this),
+        )
+    }
+    try {
+        return functionCall().then((result) => handleRustResult(result, liftResult, liftError));
+    }  catch (error) {
+        return Promise.reject(error)
+    }}
+    setLastSync(lastSync) {
+    const liftResult = (result) => undefined;
+    const liftError = (data) => FfiConverterTypeTabsError.lift(data);
+    const functionCall = () => {
+        FfiConverterI64.checkType("lastSync", lastSync);
+        return UniFFIScaffolding.callAsync(
+            8, // tabs:tabs_af8e_TabsBridgedEngine_set_last_sync
+            FfiConverterTypeTabsBridgedEngine.lower(this),
+            FfiConverterI64.lower(lastSync),
+        )
+    }
+    try {
+        return functionCall().then((result) => handleRustResult(result, liftResult, liftError));
+    }  catch (error) {
+        return Promise.reject(error)
+    }}
+    syncId() {
+    const liftResult = (result) => FfiConverterOptionalstring.lift(result);
+    const liftError = (data) => FfiConverterTypeTabsError.lift(data);
+    const functionCall = () => {
+        return UniFFIScaffolding.callAsync(
+            9, // tabs:tabs_af8e_TabsBridgedEngine_sync_id
+            FfiConverterTypeTabsBridgedEngine.lower(this),
+        )
+    }
+    try {
+        return functionCall().then((result) => handleRustResult(result, liftResult, liftError));
+    }  catch (error) {
+        return Promise.reject(error)
+    }}
+    resetSyncId() {
+    const liftResult = (result) => FfiConverterString.lift(result);
+    const liftError = (data) => FfiConverterTypeTabsError.lift(data);
+    const functionCall = () => {
+        return UniFFIScaffolding.callAsync(
+            10, // tabs:tabs_af8e_TabsBridgedEngine_reset_sync_id
+            FfiConverterTypeTabsBridgedEngine.lower(this),
+        )
+    }
+    try {
+        return functionCall().then((result) => handleRustResult(result, liftResult, liftError));
+    }  catch (error) {
+        return Promise.reject(error)
+    }}
+    ensureCurrentSyncId(newSyncId) {
+    const liftResult = (result) => FfiConverterString.lift(result);
+    const liftError = (data) => FfiConverterTypeTabsError.lift(data);
+    const functionCall = () => {
+        FfiConverterString.checkType("newSyncId", newSyncId);
+        return UniFFIScaffolding.callAsync(
+            11, // tabs:tabs_af8e_TabsBridgedEngine_ensure_current_sync_id
+            FfiConverterTypeTabsBridgedEngine.lower(this),
+            FfiConverterString.lower(newSyncId),
+        )
+    }
+    try {
+        return functionCall().then((result) => handleRustResult(result, liftResult, liftError));
+    }  catch (error) {
+        return Promise.reject(error)
+    }}
+    prepareForSync(clientData) {
+    const liftResult = (result) => undefined;
+    const liftError = (data) => FfiConverterTypeTabsError.lift(data);
+    const functionCall = () => {
+        FfiConverterString.checkType("clientData", clientData);
+        return UniFFIScaffolding.callAsync(
+            12, // tabs:tabs_af8e_TabsBridgedEngine_prepare_for_sync
+            FfiConverterTypeTabsBridgedEngine.lower(this),
+            FfiConverterString.lower(clientData),
+        )
+    }
+    try {
+        return functionCall().then((result) => handleRustResult(result, liftResult, liftError));
+    }  catch (error) {
+        return Promise.reject(error)
+    }}
+    syncStarted() {
+    const liftResult = (result) => undefined;
+    const liftError = (data) => FfiConverterTypeTabsError.lift(data);
+    const functionCall = () => {
+        return UniFFIScaffolding.callAsync(
+            13, // tabs:tabs_af8e_TabsBridgedEngine_sync_started
+            FfiConverterTypeTabsBridgedEngine.lower(this),
+        )
+    }
+    try {
+        return functionCall().then((result) => handleRustResult(result, liftResult, liftError));
+    }  catch (error) {
+        return Promise.reject(error)
+    }}
+    storeIncoming(incomingEnvelopesAsJson) {
+    const liftResult = (result) => undefined;
+    const liftError = (data) => FfiConverterTypeTabsError.lift(data);
+    const functionCall = () => {
+        FfiConverterSequencestring.checkType("incomingEnvelopesAsJson", incomingEnvelopesAsJson);
+        return UniFFIScaffolding.callAsync(
+            14, // tabs:tabs_af8e_TabsBridgedEngine_store_incoming
+            FfiConverterTypeTabsBridgedEngine.lower(this),
+            FfiConverterSequencestring.lower(incomingEnvelopesAsJson),
+        )
+    }
+    try {
+        return functionCall().then((result) => handleRustResult(result, liftResult, liftError));
+    }  catch (error) {
+        return Promise.reject(error)
+    }}
+    apply() {
+    const liftResult = (result) => FfiConverterSequencestring.lift(result);
+    const liftError = (data) => FfiConverterTypeTabsError.lift(data);
+    const functionCall = () => {
+        return UniFFIScaffolding.callAsync(
+            15, // tabs:tabs_af8e_TabsBridgedEngine_apply
+            FfiConverterTypeTabsBridgedEngine.lower(this),
+        )
+    }
+    try {
+        return functionCall().then((result) => handleRustResult(result, liftResult, liftError));
+    }  catch (error) {
+        return Promise.reject(error)
+    }}
+    setUploaded(newTimestamp,uploadedIds) {
+    const liftResult = (result) => undefined;
+    const liftError = (data) => FfiConverterTypeTabsError.lift(data);
+    const functionCall = () => {
+        FfiConverterI64.checkType("newTimestamp", newTimestamp);
+        FfiConverterSequenceTypeTabsGuid.checkType("uploadedIds", uploadedIds);
+        return UniFFIScaffolding.callAsync(
+            16, // tabs:tabs_af8e_TabsBridgedEngine_set_uploaded
+            FfiConverterTypeTabsBridgedEngine.lower(this),
+            FfiConverterI64.lower(newTimestamp),
+            FfiConverterSequenceTypeTabsGuid.lower(uploadedIds),
+        )
+    }
+    try {
+        return functionCall().then((result) => handleRustResult(result, liftResult, liftError));
+    }  catch (error) {
+        return Promise.reject(error)
+    }}
+    syncFinished() {
+    const liftResult = (result) => undefined;
+    const liftError = (data) => FfiConverterTypeTabsError.lift(data);
+    const functionCall = () => {
+        return UniFFIScaffolding.callAsync(
+            17, // tabs:tabs_af8e_TabsBridgedEngine_sync_finished
+            FfiConverterTypeTabsBridgedEngine.lower(this),
+        )
+    }
+    try {
+        return functionCall().then((result) => handleRustResult(result, liftResult, liftError));
+    }  catch (error) {
+        return Promise.reject(error)
+    }}
+    reset() {
+    const liftResult = (result) => undefined;
+    const liftError = (data) => FfiConverterTypeTabsError.lift(data);
+    const functionCall = () => {
+        return UniFFIScaffolding.callAsync(
+            18, // tabs:tabs_af8e_TabsBridgedEngine_reset
+            FfiConverterTypeTabsBridgedEngine.lower(this),
+        )
+    }
+    try {
+        return functionCall().then((result) => handleRustResult(result, liftResult, liftError));
+    }  catch (error) {
+        return Promise.reject(error)
+    }}
+    wipe() {
+    const liftResult = (result) => undefined;
+    const liftError = (data) => FfiConverterTypeTabsError.lift(data);
+    const functionCall = () => {
+        return UniFFIScaffolding.callAsync(
+            19, // tabs:tabs_af8e_TabsBridgedEngine_wipe
+            FfiConverterTypeTabsBridgedEngine.lower(this),
+        )
+    }
+    try {
+        return functionCall().then((result) => handleRustResult(result, liftResult, liftError));
+    }  catch (error) {
+        return Promise.reject(error)
+    }}
+
+}
+
+class FfiConverterTypeTabsBridgedEngine extends FfiConverter {
+    static lift(value) {
+        const opts = {};
+        opts[constructUniffiObject] = value;
+        return new TabsBridgedEngine(opts);
+    }
+
+    static lower(value) {
+        return value[uniffiObjectPtr];
+    }
+
+    static read(dataStream) {
+        return this.lift(dataStream.readPointerTabsBridgedEngine());
+    }
+
+    static write(dataStream, value) {
+        dataStream.writePointerTabsBridgedEngine(value[uniffiObjectPtr]);
+    }
+
+    static computeSize(value) {
+        return 8;
+    }
+}
+
+EXPORTED_SYMBOLS.push("TabsBridgedEngine");
+
+// Export the FFIConverter object to make external types work.
+EXPORTED_SYMBOLS.push("FfiConverterTypeTabsBridgedEngine");
+
+class TabsStore {
+    // Use `init` to instantiate this class.
+    // DO NOT USE THIS CONSTRUCTOR DIRECTLY
+    constructor(opts) {
+        if (!Object.prototype.hasOwnProperty.call(opts, constructUniffiObject)) {
+            throw new UniFFIError("Attempting to construct an object using the JavaScript constructor directly" +
+            "Please use a UDL defined constructor, or the init function for the primary constructor")
+        }
+        if (!opts[constructUniffiObject] instanceof UniFFIPointer) {
+            throw new UniFFIError("Attempting to create a UniFFI object with a pointer that is not an instance of UniFFIPointer")
+        }
+        this[uniffiObjectPtr] = opts[constructUniffiObject];
+    }
+    /**
+     * An async constructor for TabsStore.
+     * 
+     * @returns {Promise<TabsStore>}: A promise that resolves
+     *      to a newly constructed TabsStore
+     */
+    static init(path) {
+    const liftResult = (result) => FfiConverterTypeTabsStore.lift(result);
+    const liftError = null;
+    const functionCall = () => {
+        FfiConverterString.checkType("path", path);
+        return UniFFIScaffolding.callAsync(
+            0, // tabs:tabs_af8e_TabsStore_new
+            FfiConverterString.lower(path),
+        )
+    }
+    try {
+        return functionCall().then((result) => handleRustResult(result, liftResult, liftError));
+    }  catch (error) {
+        return Promise.reject(error)
+    }}
+    getAll() {
+    const liftResult = (result) => FfiConverterSequenceTypeClientRemoteTabs.lift(result);
+    const liftError = null;
+    const functionCall = () => {
+        return UniFFIScaffolding.callAsync(
+            1, // tabs:tabs_af8e_TabsStore_get_all
+            FfiConverterTypeTabsStore.lower(this),
+        )
+    }
+    try {
+        return functionCall().then((result) => handleRustResult(result, liftResult, liftError));
+    }  catch (error) {
+        return Promise.reject(error)
+    }}
+    setLocalTabs(remoteTabs) {
+    const liftResult = (result) => undefined;
+    const liftError = null;
+    const functionCall = () => {
+        FfiConverterSequenceTypeRemoteTabRecord.checkType("remoteTabs", remoteTabs);
+        return UniFFIScaffolding.callAsync(
+            2, // tabs:tabs_af8e_TabsStore_set_local_tabs
+            FfiConverterTypeTabsStore.lower(this),
+            FfiConverterSequenceTypeRemoteTabRecord.lower(remoteTabs),
+        )
+    }
+    try {
+        return functionCall().then((result) => handleRustResult(result, liftResult, liftError));
+    }  catch (error) {
+        return Promise.reject(error)
+    }}
+    registerWithSyncManager() {
+    const liftResult = (result) => undefined;
+    const liftError = null;
+    const functionCall = () => {
+        return UniFFIScaffolding.callAsync(
+            3, // tabs:tabs_af8e_TabsStore_register_with_sync_manager
+            FfiConverterTypeTabsStore.lower(this),
+        )
+    }
+    try {
+        return functionCall().then((result) => handleRustResult(result, liftResult, liftError));
+    }  catch (error) {
+        return Promise.reject(error)
+    }}
+    reset() {
+    const liftResult = (result) => undefined;
+    const liftError = (data) => FfiConverterTypeTabsError.lift(data);
+    const functionCall = () => {
+        return UniFFIScaffolding.callAsync(
+            4, // tabs:tabs_af8e_TabsStore_reset
+            FfiConverterTypeTabsStore.lower(this),
+        )
+    }
+    try {
+        return functionCall().then((result) => handleRustResult(result, liftResult, liftError));
+    }  catch (error) {
+        return Promise.reject(error)
+    }}
+    sync(keyId,accessToken,syncKey,tokenserverUrl,localId) {
+    const liftResult = (result) => FfiConverterString.lift(result);
+    const liftError = (data) => FfiConverterTypeTabsError.lift(data);
+    const functionCall = () => {
+        FfiConverterString.checkType("keyId", keyId);
+        FfiConverterString.checkType("accessToken", accessToken);
+        FfiConverterString.checkType("syncKey", syncKey);
+        FfiConverterString.checkType("tokenserverUrl", tokenserverUrl);
+        FfiConverterString.checkType("localId", localId);
+        return UniFFIScaffolding.callAsync(
+            5, // tabs:tabs_af8e_TabsStore_sync
+            FfiConverterTypeTabsStore.lower(this),
+            FfiConverterString.lower(keyId),
+            FfiConverterString.lower(accessToken),
+            FfiConverterString.lower(syncKey),
+            FfiConverterString.lower(tokenserverUrl),
+            FfiConverterString.lower(localId),
+        )
+    }
+    try {
+        return functionCall().then((result) => handleRustResult(result, liftResult, liftError));
+    }  catch (error) {
+        return Promise.reject(error)
+    }}
+    bridgedEngine() {
+    const liftResult = (result) => FfiConverterTypeTabsBridgedEngine.lift(result);
+    const liftError = null;
+    const functionCall = () => {
+        return UniFFIScaffolding.callAsync(
+            6, // tabs:tabs_af8e_TabsStore_bridged_engine
+            FfiConverterTypeTabsStore.lower(this),
+        )
+    }
+    try {
+        return functionCall().then((result) => handleRustResult(result, liftResult, liftError));
+    }  catch (error) {
+        return Promise.reject(error)
+    }}
+
+}
+
+class FfiConverterTypeTabsStore extends FfiConverter {
+    static lift(value) {
+        const opts = {};
+        opts[constructUniffiObject] = value;
+        return new TabsStore(opts);
+    }
+
+    static lower(value) {
+        return value[uniffiObjectPtr];
+    }
+
+    static read(dataStream) {
+        return this.lift(dataStream.readPointerTabsStore());
+    }
+
+    static write(dataStream, value) {
+        dataStream.writePointerTabsStore(value[uniffiObjectPtr]);
+    }
+
+    static computeSize(value) {
+        return 8;
+    }
+}
+
+EXPORTED_SYMBOLS.push("TabsStore");
+
+// Export the FFIConverter object to make external types work.
+EXPORTED_SYMBOLS.push("FfiConverterTypeTabsStore");
+
+class ClientRemoteTabs {
+    constructor(clientId,clientName,deviceType,remoteTabs) {
+        FfiConverterString.checkType("clientId", clientId);
+        FfiConverterString.checkType("clientName", clientName);
+        FfiConverterTypeTabsDeviceType.checkType("deviceType", deviceType);
+        FfiConverterSequenceTypeRemoteTabRecord.checkType("remoteTabs", remoteTabs);
+        this.clientId = clientId;
+        this.clientName = clientName;
+        this.deviceType = deviceType;
+        this.remoteTabs = remoteTabs;
+    }
+    equals(other) {
+        return (
+            this.clientId == other.clientId &&
+            this.clientName == other.clientName &&
+            this.deviceType == other.deviceType &&
+            this.remoteTabs == other.remoteTabs
+        )
+    }
+}
+
+class FfiConverterTypeClientRemoteTabs extends FfiConverter {
+    static lift(buf) {
+        return this.read(new ArrayBufferDataStream(buf));
+    }
+    static lower(value) {
+        const buf = new ArrayBuffer(this.computeSize(value));
+        const dataStream = new ArrayBufferDataStream(buf);
+        this.write(dataStream, value);
+        return buf;
+    }
+    static read(dataStream) {
+        return new ClientRemoteTabs(
+            FfiConverterString.read(dataStream), 
+            FfiConverterString.read(dataStream), 
+            FfiConverterTypeTabsDeviceType.read(dataStream), 
+            FfiConverterSequenceTypeRemoteTabRecord.read(dataStream)
+        );
+    }
+    static write(dataStream, value) {
+        FfiConverterString.write(dataStream, value.clientId);
+        FfiConverterString.write(dataStream, value.clientName);
+        FfiConverterTypeTabsDeviceType.write(dataStream, value.deviceType);
+        FfiConverterSequenceTypeRemoteTabRecord.write(dataStream, value.remoteTabs);
+    }
+
+    static computeSize(value) {
+        let totalSize = 0;
+        totalSize += FfiConverterString.computeSize(value.clientId);
+        totalSize += FfiConverterString.computeSize(value.clientName);
+        totalSize += FfiConverterTypeTabsDeviceType.computeSize(value.deviceType);
+        totalSize += FfiConverterSequenceTypeRemoteTabRecord.computeSize(value.remoteTabs);
+        return totalSize
+    }
+}
+
+EXPORTED_SYMBOLS.push("ClientRemoteTabs");
+
+// Export the FFIConverter object to make external types work.
+EXPORTED_SYMBOLS.push("FfiConverterTypeClientRemoteTabs");
+
+class RemoteTabRecord {
+    constructor(title,urlHistory,icon,lastUsed) {
+        FfiConverterString.checkType("title", title);
+        FfiConverterSequencestring.checkType("urlHistory", urlHistory);
+        FfiConverterOptionalstring.checkType("icon", icon);
+        FfiConverterI64.checkType("lastUsed", lastUsed);
+        this.title = title;
+        this.urlHistory = urlHistory;
+        this.icon = icon;
+        this.lastUsed = lastUsed;
+    }
+    equals(other) {
+        return (
+            this.title == other.title &&
+            this.urlHistory == other.urlHistory &&
+            this.icon == other.icon &&
+            this.lastUsed == other.lastUsed
+        )
+    }
+}
+
+class FfiConverterTypeRemoteTabRecord extends FfiConverter {
+    static lift(buf) {
+        return this.read(new ArrayBufferDataStream(buf));
+    }
+    static lower(value) {
+        const buf = new ArrayBuffer(this.computeSize(value));
+        const dataStream = new ArrayBufferDataStream(buf);
+        this.write(dataStream, value);
+        return buf;
+    }
+    static read(dataStream) {
+        return new RemoteTabRecord(
+            FfiConverterString.read(dataStream), 
+            FfiConverterSequencestring.read(dataStream), 
+            FfiConverterOptionalstring.read(dataStream), 
+            FfiConverterI64.read(dataStream)
+        );
+    }
+    static write(dataStream, value) {
+        FfiConverterString.write(dataStream, value.title);
+        FfiConverterSequencestring.write(dataStream, value.urlHistory);
+        FfiConverterOptionalstring.write(dataStream, value.icon);
+        FfiConverterI64.write(dataStream, value.lastUsed);
+    }
+
+    static computeSize(value) {
+        let totalSize = 0;
+        totalSize += FfiConverterString.computeSize(value.title);
+        totalSize += FfiConverterSequencestring.computeSize(value.urlHistory);
+        totalSize += FfiConverterOptionalstring.computeSize(value.icon);
+        totalSize += FfiConverterI64.computeSize(value.lastUsed);
+        return totalSize
+    }
+}
+
+EXPORTED_SYMBOLS.push("RemoteTabRecord");
+
+// Export the FFIConverter object to make external types work.
+EXPORTED_SYMBOLS.push("FfiConverterTypeRemoteTabRecord");
+
+const TabsDeviceType = {
+    DESKTOP: 1,
+    MOBILE: 2,
+    TABLET: 3,
+    VR: 4,
+    TV: 5,
+    UNKNOWN: 6,
+};
+
+Object.freeze(TabsDeviceType);
+class FfiConverterTypeTabsDeviceType extends FfiConverterArrayBuffer {
+    static read(dataStream) {
+        switch (dataStream.readInt32()) {
+            case 1:
+                return TabsDeviceType.DESKTOP
+            case 2:
+                return TabsDeviceType.MOBILE
+            case 3:
+                return TabsDeviceType.TABLET
+            case 4:
+                return TabsDeviceType.VR
+            case 5:
+                return TabsDeviceType.TV
+            case 6:
+                return TabsDeviceType.UNKNOWN
+            default:
+                return new Error("Unknown TabsDeviceType variant");
+        }
+    }
+
+    static write(dataStream, value) {
+        if (value === TabsDeviceType.DESKTOP) {
+            dataStream.writeInt32(1);
+            return;
+        }
+        if (value === TabsDeviceType.MOBILE) {
+            dataStream.writeInt32(2);
+            return;
+        }
+        if (value === TabsDeviceType.TABLET) {
+            dataStream.writeInt32(3);
+            return;
+        }
+        if (value === TabsDeviceType.VR) {
+            dataStream.writeInt32(4);
+            return;
+        }
+        if (value === TabsDeviceType.TV) {
+            dataStream.writeInt32(5);
+            return;
+        }
+        if (value === TabsDeviceType.UNKNOWN) {
+            dataStream.writeInt32(6);
+            return;
+        }
+        return new Error("Unknown TabsDeviceType variant");
+    }
+
+    static computeSize(value) {
+        return 4;
+    }
+}
+
+EXPORTED_SYMBOLS.push("TabsDeviceType");
+
+// Export the FFIConverter object to make external types work.
+EXPORTED_SYMBOLS.push("FfiConverterTypeTabsDeviceType");
+
+
+
+class TabsError extends Error {}
+EXPORTED_SYMBOLS.push("TabsError");
+
+
+class SyncAdapterError extends TabsError {
+    
+    constructor(message, ...params) {
+        super(...params);
+        this.message = message;
+    }
+}
+EXPORTED_SYMBOLS.push("SyncAdapterError");
+class SyncResetError extends TabsError {
+    
+    constructor(message, ...params) {
+        super(...params);
+        this.message = message;
+    }
+}
+EXPORTED_SYMBOLS.push("SyncResetError");
+class JsonError extends TabsError {
+    
+    constructor(message, ...params) {
+        super(...params);
+        this.message = message;
+    }
+}
+EXPORTED_SYMBOLS.push("JsonError");
+class MissingLocalIdError extends TabsError {
+    
+    constructor(message, ...params) {
+        super(...params);
+        this.message = message;
+    }
+}
+EXPORTED_SYMBOLS.push("MissingLocalIdError");
+class UrlParseError extends TabsError {
+    
+    constructor(message, ...params) {
+        super(...params);
+        this.message = message;
+    }
+}
+EXPORTED_SYMBOLS.push("UrlParseError");
+class SqlError extends TabsError {
+    
+    constructor(message, ...params) {
+        super(...params);
+        this.message = message;
+    }
+}
+EXPORTED_SYMBOLS.push("SqlError");
+class OpenDatabaseError extends TabsError {
+    
+    constructor(message, ...params) {
+        super(...params);
+        this.message = message;
+    }
+}
+EXPORTED_SYMBOLS.push("OpenDatabaseError");
+
+class FfiConverterTypeTabsError extends FfiConverterArrayBuffer {
+    static read(dataStream) {
+        switch (dataStream.readInt32()) {
+            case 1:
+                return new SyncAdapterError(FfiConverterString.read(dataStream));
+            case 2:
+                return new SyncResetError(FfiConverterString.read(dataStream));
+            case 3:
+                return new JsonError(FfiConverterString.read(dataStream));
+            case 4:
+                return new MissingLocalIdError(FfiConverterString.read(dataStream));
+            case 5:
+                return new UrlParseError(FfiConverterString.read(dataStream));
+            case 6:
+                return new SqlError(FfiConverterString.read(dataStream));
+            case 7:
+                return new OpenDatabaseError(FfiConverterString.read(dataStream));
+            default:
+                return new Error("Unknown TabsError variant");
+        }
+    }
+}
+
+// Export the FFIConverter object to make external types work.
+EXPORTED_SYMBOLS.push("FfiConverterTypeTabsError");
+
+class FfiConverterOptionalstring extends FfiConverterArrayBuffer {
+    static checkType(name, value) {
+        if (value !== undefined && value !== null) {
+            FfiConverterString.checkType(name, value)
+        }
+    }
+
+    static read(dataStream) {
+        const code = dataStream.readUint8(0);
+        switch (code) {
+            case 0:
+                return null
+            case 1:
+                return FfiConverterString.read(dataStream)
+            default:
+                throw UniFFIError(`Unexpected code: ${code}`);
+        }
+    }
+
+    static write(dataStream, value) {
+        if (value === null || value === undefined) {
+            dataStream.writeUint8(0);
+            return;
+        }
+        dataStream.writeUint8(1);
+        FfiConverterString.write(dataStream, value)
+    }
+
+    static computeSize(value) {
+        if (value === null || value === undefined) {
+            return 1;
+        }
+        return 1 + FfiConverterString.computeSize(value)
+    }
+}
+
+// Export the FFIConverter object to make external types work.
+EXPORTED_SYMBOLS.push("FfiConverterOptionalstring");
+
+class FfiConverterSequencestring extends FfiConverterArrayBuffer {
+    static read(dataStream) {
+        const len = dataStream.readInt32();
+        const arr = [];
+        for (let i = 0; i < len; i++) {
+            arr.push(FfiConverterString.read(dataStream));
+        }
+        return arr;
+    }
+
+    static write(dataStream, value) {
+        dataStream.writeInt32(value.length);
+        value.forEach((innerValue) => {
+            FfiConverterString.write(dataStream, innerValue);
+        })
+    }
+
+    static computeSize(value) {
+        // The size of the length
+        let size = 4;
+        for (const innerValue of value) {
+            size += FfiConverterString.computeSize(innerValue);
+        }
+        return size;
+    }
+}
+
+// Export the FFIConverter object to make external types work.
+EXPORTED_SYMBOLS.push("FfiConverterSequencestring");
+
+class FfiConverterSequenceTypeClientRemoteTabs extends FfiConverterArrayBuffer {
+    static read(dataStream) {
+        const len = dataStream.readInt32();
+        const arr = [];
+        for (let i = 0; i < len; i++) {
+            arr.push(FfiConverterTypeClientRemoteTabs.read(dataStream));
+        }
+        return arr;
+    }
+
+    static write(dataStream, value) {
+        dataStream.writeInt32(value.length);
+        value.forEach((innerValue) => {
+            FfiConverterTypeClientRemoteTabs.write(dataStream, innerValue);
+        })
+    }
+
+    static computeSize(value) {
+        // The size of the length
+        let size = 4;
+        for (const innerValue of value) {
+            size += FfiConverterTypeClientRemoteTabs.computeSize(innerValue);
+        }
+        return size;
+    }
+}
+
+// Export the FFIConverter object to make external types work.
+EXPORTED_SYMBOLS.push("FfiConverterSequenceTypeClientRemoteTabs");
+
+class FfiConverterSequenceTypeRemoteTabRecord extends FfiConverterArrayBuffer {
+    static read(dataStream) {
+        const len = dataStream.readInt32();
+        const arr = [];
+        for (let i = 0; i < len; i++) {
+            arr.push(FfiConverterTypeRemoteTabRecord.read(dataStream));
+        }
+        return arr;
+    }
+
+    static write(dataStream, value) {
+        dataStream.writeInt32(value.length);
+        value.forEach((innerValue) => {
+            FfiConverterTypeRemoteTabRecord.write(dataStream, innerValue);
+        })
+    }
+
+    static computeSize(value) {
+        // The size of the length
+        let size = 4;
+        for (const innerValue of value) {
+            size += FfiConverterTypeRemoteTabRecord.computeSize(innerValue);
+        }
+        return size;
+    }
+}
+
+// Export the FFIConverter object to make external types work.
+EXPORTED_SYMBOLS.push("FfiConverterSequenceTypeRemoteTabRecord");
+
+class FfiConverterSequenceTypeTabsGuid extends FfiConverterArrayBuffer {
+    static read(dataStream) {
+        const len = dataStream.readInt32();
+        const arr = [];
+        for (let i = 0; i < len; i++) {
+            arr.push(FfiConverterTypeTabsGuid.read(dataStream));
+        }
+        return arr;
+    }
+
+    static write(dataStream, value) {
+        dataStream.writeInt32(value.length);
+        value.forEach((innerValue) => {
+            FfiConverterTypeTabsGuid.write(dataStream, innerValue);
+        })
+    }
+
+    static computeSize(value) {
+        // The size of the length
+        let size = 4;
+        for (const innerValue of value) {
+            size += FfiConverterTypeTabsGuid.computeSize(innerValue);
+        }
+        return size;
+    }
+}
+
+// Export the FFIConverter object to make external types work.
+EXPORTED_SYMBOLS.push("FfiConverterSequenceTypeTabsGuid");
+
+class FfiConverterTypeTabsGuid extends FfiConverter {
+
+    static lift(buf) {  
+        return FfiConverterString.lift(buf);    
+    }
+    
+    static lower(buf) {
+        return FfiConverterString.lower(buf);
+    }
+    
+    static write(dataStream, value) {
+        FfiConverterString.write(dataStream, value);
+    } 
+    
+    static read(buf) {
+        return FfiConverterString.read(buf);
+    }
+    
+    static computeSize(value) {
+        return FfiConverterString.computeSize(value);
+    }
+}
+// TODO: We should also allow JS to customize the type eventually.
+
+// Export the FFIConverter object to make external types work.
+EXPORTED_SYMBOLS.push("FfiConverterTypeTabsGuid");
+
+
+
+
diff --git a/www/firefox/files/UniFFIGeneratedScaffolding.cpp b/www/firefox/files/UniFFIGeneratedScaffolding.cpp
new file mode 100644
index 000000000000..0a6d99cea095
--- /dev/null
+++ b/www/firefox/files/UniFFIGeneratedScaffolding.cpp
@@ -0,0 +1,283 @@
+// Generated by uniffi-bindgen-gecko-js.  DO NOT EDIT.
+
+#include "nsString.h"
+#include "nsPrintfCString.h"
+#include "mozilla/Maybe.h"
+#include "mozilla/dom/UniFFIScaffolding.h"
+#include "mozilla/dom/ScaffoldingCall.h"
+
+namespace mozilla::uniffi {
+
+using dom::ArrayBuffer;
+using dom::GlobalObject;
+using dom::RootedDictionary;
+using dom::Promise;
+using dom::ScaffoldingType;
+using dom::Sequence;
+using dom::UniFFIPointer;
+using dom::UniFFIScaffoldingCallResult;
+
+// Define scaffolding functions from UniFFI
+extern "C" {
+  void ffi_tabs_af8e_TabsStore_object_free(void *, RustCallStatus*);
+  void * tabs_af8e_TabsStore_new(RustBuffer, RustCallStatus*);
+  RustBuffer tabs_af8e_TabsStore_get_all(void *, RustCallStatus*);
+  void tabs_af8e_TabsStore_set_local_tabs(void *, RustBuffer, RustCallStatus*);
+  void tabs_af8e_TabsStore_register_with_sync_manager(void *, RustCallStatus*);
+  void tabs_af8e_TabsStore_reset(void *, RustCallStatus*);
+  RustBuffer tabs_af8e_TabsStore_sync(void *, RustBuffer, RustBuffer, RustBuffer, RustBuffer, RustBuffer, RustCallStatus*);
+  void * tabs_af8e_TabsStore_bridged_engine(void *, RustCallStatus*);
+  void ffi_tabs_af8e_TabsBridgedEngine_object_free(void *, RustCallStatus*);
+  int64_t tabs_af8e_TabsBridgedEngine_last_sync(void *, RustCallStatus*);
+  void tabs_af8e_TabsBridgedEngine_set_last_sync(void *, int64_t, RustCallStatus*);
+  RustBuffer tabs_af8e_TabsBridgedEngine_sync_id(void *, RustCallStatus*);
+  RustBuffer tabs_af8e_TabsBridgedEngine_reset_sync_id(void *, RustCallStatus*);
+  RustBuffer tabs_af8e_TabsBridgedEngine_ensure_current_sync_id(void *, RustBuffer, RustCallStatus*);
+  void tabs_af8e_TabsBridgedEngine_prepare_for_sync(void *, RustBuffer, RustCallStatus*);
+  void tabs_af8e_TabsBridgedEngine_sync_started(void *, RustCallStatus*);
+  void tabs_af8e_TabsBridgedEngine_store_incoming(void *, RustBuffer, RustCallStatus*);
+  RustBuffer tabs_af8e_TabsBridgedEngine_apply(void *, RustCallStatus*);
+  void tabs_af8e_TabsBridgedEngine_set_uploaded(void *, int64_t, RustBuffer, RustCallStatus*);
+  void tabs_af8e_TabsBridgedEngine_sync_finished(void *, RustCallStatus*);
+  void tabs_af8e_TabsBridgedEngine_reset(void *, RustCallStatus*);
+  void tabs_af8e_TabsBridgedEngine_wipe(void *, RustCallStatus*);
+}
+
+// Define pointer types
+const static mozilla::uniffi::UniFFIPointerType kTabsTabsStorePointerType {
+  "tabs::TabsStore"_ns,
+  ffi_tabs_af8e_TabsStore_object_free
+};
+const static mozilla::uniffi::UniFFIPointerType kTabsTabsBridgedEnginePointerType {
+  "tabs::TabsBridgedEngine"_ns,
+  ffi_tabs_af8e_TabsBridgedEngine_object_free
+};
+
+Maybe<already_AddRefed<Promise>> UniFFICallAsync(const GlobalObject& aGlobal, uint64_t aId, const Sequence<ScaffoldingType>& aArgs, ErrorResult& aError) {
+  switch (aId) {
+    case 0: { // tabs:tabs_af8e_TabsStore_new
+      using CallHandler = ScaffoldingCallHandler<ScaffoldingObjectConverter<&kTabsTabsStorePointerType>, ScaffoldingConverter<RustBuffer>>;
+      return Some(CallHandler::CallAsync(tabs_af8e_TabsStore_new, aGlobal, aArgs, "tabs_af8e_TabsStore_new: "_ns, aError));
+    }
+    case 1: { // tabs:tabs_af8e_TabsStore_get_all
+      using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kTabsTabsStorePointerType>>;
+      return Some(CallHandler::CallAsync(tabs_af8e_TabsStore_get_all, aGlobal, aArgs, "tabs_af8e_TabsStore_get_all: "_ns, aError));
+    }
+    case 2: { // tabs:tabs_af8e_TabsStore_set_local_tabs
+      using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<void>, ScaffoldingObjectConverter<&kTabsTabsStorePointerType>, ScaffoldingConverter<RustBuffer>>;
+      return Some(CallHandler::CallAsync(tabs_af8e_TabsStore_set_local_tabs, aGlobal, aArgs, "tabs_af8e_TabsStore_set_local_tabs: "_ns, aError));
+    }
+    case 3: { // tabs:tabs_af8e_TabsStore_register_with_sync_manager
+      using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<void>, ScaffoldingObjectConverter<&kTabsTabsStorePointerType>>;
+      return Some(CallHandler::CallAsync(tabs_af8e_TabsStore_register_with_sync_manager, aGlobal, aArgs, "tabs_af8e_TabsStore_register_with_sync_manager: "_ns, aError));
+    }
+    case 4: { // tabs:tabs_af8e_TabsStore_reset
+      using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<void>, ScaffoldingObjectConverter<&kTabsTabsStorePointerType>>;
+      return Some(CallHandler::CallAsync(tabs_af8e_TabsStore_reset, aGlobal, aArgs, "tabs_af8e_TabsStore_reset: "_ns, aError));
+    }
+    case 5: { // tabs:tabs_af8e_TabsStore_sync
+      using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kTabsTabsStorePointerType>, ScaffoldingConverter<RustBuffer>, ScaffoldingConverter<RustBuffer>, ScaffoldingConverter<RustBuffer>, ScaffoldingConverter<RustBuffer>, ScaffoldingConverter<RustBuffer>>;
+      return Some(CallHandler::CallAsync(tabs_af8e_TabsStore_sync, aGlobal, aArgs, "tabs_af8e_TabsStore_sync: "_ns, aError));
+    }
+    case 6: { // tabs:tabs_af8e_TabsStore_bridged_engine
+      using CallHandler = ScaffoldingCallHandler<ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>, ScaffoldingObjectConverter<&kTabsTabsStorePointerType>>;
+      return Some(CallHandler::CallAsync(tabs_af8e_TabsStore_bridged_engine, aGlobal, aArgs, "tabs_af8e_TabsStore_bridged_engine: "_ns, aError));
+    }
+    case 7: { // tabs:tabs_af8e_TabsBridgedEngine_last_sync
+      using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<int64_t>, ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>>;
+      return Some(CallHandler::CallAsync(tabs_af8e_TabsBridgedEngine_last_sync, aGlobal, aArgs, "tabs_af8e_TabsBridgedEngine_last_sync: "_ns, aError));
+    }
+    case 8: { // tabs:tabs_af8e_TabsBridgedEngine_set_last_sync
+      using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<void>, ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>, ScaffoldingConverter<int64_t>>;
+      return Some(CallHandler::CallAsync(tabs_af8e_TabsBridgedEngine_set_last_sync, aGlobal, aArgs, "tabs_af8e_TabsBridgedEngine_set_last_sync: "_ns, aError));
+    }
+    case 9: { // tabs:tabs_af8e_TabsBridgedEngine_sync_id
+      using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>>;
+      return Some(CallHandler::CallAsync(tabs_af8e_TabsBridgedEngine_sync_id, aGlobal, aArgs, "tabs_af8e_TabsBridgedEngine_sync_id: "_ns, aError));
+    }
+    case 10: { // tabs:tabs_af8e_TabsBridgedEngine_reset_sync_id
+      using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>>;
+      return Some(CallHandler::CallAsync(tabs_af8e_TabsBridgedEngine_reset_sync_id, aGlobal, aArgs, "tabs_af8e_TabsBridgedEngine_reset_sync_id: "_ns, aError));
+    }
+    case 11: { // tabs:tabs_af8e_TabsBridgedEngine_ensure_current_sync_id
+      using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>, ScaffoldingConverter<RustBuffer>>;
+      return Some(CallHandler::CallAsync(tabs_af8e_TabsBridgedEngine_ensure_current_sync_id, aGlobal, aArgs, "tabs_af8e_TabsBridgedEngine_ensure_current_sync_id: "_ns, aError));
+    }
+    case 12: { // tabs:tabs_af8e_TabsBridgedEngine_prepare_for_sync
+      using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<void>, ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>, ScaffoldingConverter<RustBuffer>>;
+      return Some(CallHandler::CallAsync(tabs_af8e_TabsBridgedEngine_prepare_for_sync, aGlobal, aArgs, "tabs_af8e_TabsBridgedEngine_prepare_for_sync: "_ns, aError));
+    }
+    case 13: { // tabs:tabs_af8e_TabsBridgedEngine_sync_started
+      using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<void>, ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>>;
+      return Some(CallHandler::CallAsync(tabs_af8e_TabsBridgedEngine_sync_started, aGlobal, aArgs, "tabs_af8e_TabsBridgedEngine_sync_started: "_ns, aError));
+    }
+    case 14: { // tabs:tabs_af8e_TabsBridgedEngine_store_incoming
+      using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<void>, ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>, ScaffoldingConverter<RustBuffer>>;
+      return Some(CallHandler::CallAsync(tabs_af8e_TabsBridgedEngine_store_incoming, aGlobal, aArgs, "tabs_af8e_TabsBridgedEngine_store_incoming: "_ns, aError));
+    }
+    case 15: { // tabs:tabs_af8e_TabsBridgedEngine_apply
+      using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>>;
+      return Some(CallHandler::CallAsync(tabs_af8e_TabsBridgedEngine_apply, aGlobal, aArgs, "tabs_af8e_TabsBridgedEngine_apply: "_ns, aError));
+    }
+    case 16: { // tabs:tabs_af8e_TabsBridgedEngine_set_uploaded
+      using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<void>, ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>, ScaffoldingConverter<int64_t>, ScaffoldingConverter<RustBuffer>>;
+      return Some(CallHandler::CallAsync(tabs_af8e_TabsBridgedEngine_set_uploaded, aGlobal, aArgs, "tabs_af8e_TabsBridgedEngine_set_uploaded: "_ns, aError));
+    }
+    case 17: { // tabs:tabs_af8e_TabsBridgedEngine_sync_finished
+      using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<void>, ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>>;
+      return Some(CallHandler::CallAsync(tabs_af8e_TabsBridgedEngine_sync_finished, aGlobal, aArgs, "tabs_af8e_TabsBridgedEngine_sync_finished: "_ns, aError));
+    }
+    case 18: { // tabs:tabs_af8e_TabsBridgedEngine_reset
+      using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<void>, ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>>;
+      return Some(CallHandler::CallAsync(tabs_af8e_TabsBridgedEngine_reset, aGlobal, aArgs, "tabs_af8e_TabsBridgedEngine_reset: "_ns, aError));
+    }
+    case 19: { // tabs:tabs_af8e_TabsBridgedEngine_wipe
+      using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<void>, ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>>;
+      return Some(CallHandler::CallAsync(tabs_af8e_TabsBridgedEngine_wipe, aGlobal, aArgs, "tabs_af8e_TabsBridgedEngine_wipe: "_ns, aError));
+    }
+  }
+  return Nothing();
+}
+
+bool UniFFICallSync(const GlobalObject& aGlobal, uint64_t aId, const Sequence<ScaffoldingType>& aArgs, RootedDictionary<UniFFIScaffoldingCallResult>& aReturnValue, ErrorResult& aError) {
+  switch (aId) {
+    case 0: { // tabs:tabs_af8e_TabsStore_new
+      using CallHandler = ScaffoldingCallHandler<ScaffoldingObjectConverter<&kTabsTabsStorePointerType>, ScaffoldingConverter<RustBuffer>>;
+      CallHandler::CallSync(tabs_af8e_TabsStore_new, aGlobal, aArgs, aReturnValue, "tabs_af8e_TabsStore_new: "_ns, aError);
+      return true;
+    }
+    case 1: { // tabs:tabs_af8e_TabsStore_get_all
+      using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kTabsTabsStorePointerType>>;
+      CallHandler::CallSync(tabs_af8e_TabsStore_get_all, aGlobal, aArgs, aReturnValue, "tabs_af8e_TabsStore_get_all: "_ns, aError);
+      return true;
+    }
+    case 2: { // tabs:tabs_af8e_TabsStore_set_local_tabs
+      using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<void>, ScaffoldingObjectConverter<&kTabsTabsStorePointerType>, ScaffoldingConverter<RustBuffer>>;
+      CallHandler::CallSync(tabs_af8e_TabsStore_set_local_tabs, aGlobal, aArgs, aReturnValue, "tabs_af8e_TabsStore_set_local_tabs: "_ns, aError);
+      return true;
+    }
+    case 3: { // tabs:tabs_af8e_TabsStore_register_with_sync_manager
+      using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<void>, ScaffoldingObjectConverter<&kTabsTabsStorePointerType>>;
+      CallHandler::CallSync(tabs_af8e_TabsStore_register_with_sync_manager, aGlobal, aArgs, aReturnValue, "tabs_af8e_TabsStore_register_with_sync_manager: "_ns, aError);
+      return true;
+    }
+    case 4: { // tabs:tabs_af8e_TabsStore_reset
+      using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<void>, ScaffoldingObjectConverter<&kTabsTabsStorePointerType>>;
+      CallHandler::CallSync(tabs_af8e_TabsStore_reset, aGlobal, aArgs, aReturnValue, "tabs_af8e_TabsStore_reset: "_ns, aError);
+      return true;
+    }
+    case 5: { // tabs:tabs_af8e_TabsStore_sync
+      using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kTabsTabsStorePointerType>, ScaffoldingConverter<RustBuffer>, ScaffoldingConverter<RustBuffer>, ScaffoldingConverter<RustBuffer>, ScaffoldingConverter<RustBuffer>, ScaffoldingConverter<RustBuffer>>;
+      CallHandler::CallSync(tabs_af8e_TabsStore_sync, aGlobal, aArgs, aReturnValue, "tabs_af8e_TabsStore_sync: "_ns, aError);
+      return true;
+    }
+    case 6: { // tabs:tabs_af8e_TabsStore_bridged_engine
+      using CallHandler = ScaffoldingCallHandler<ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>, ScaffoldingObjectConverter<&kTabsTabsStorePointerType>>;
+      CallHandler::CallSync(tabs_af8e_TabsStore_bridged_engine, aGlobal, aArgs, aReturnValue, "tabs_af8e_TabsStore_bridged_engine: "_ns, aError);
+      return true;
+    }
+    case 7: { // tabs:tabs_af8e_TabsBridgedEngine_last_sync
+      using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<int64_t>, ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>>;
+      CallHandler::CallSync(tabs_af8e_TabsBridgedEngine_last_sync, aGlobal, aArgs, aReturnValue, "tabs_af8e_TabsBridgedEngine_last_sync: "_ns, aError);
+      return true;
+    }
+    case 8: { // tabs:tabs_af8e_TabsBridgedEngine_set_last_sync
+      using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<void>, ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>, ScaffoldingConverter<int64_t>>;
+      CallHandler::CallSync(tabs_af8e_TabsBridgedEngine_set_last_sync, aGlobal, aArgs, aReturnValue, "tabs_af8e_TabsBridgedEngine_set_last_sync: "_ns, aError);
+      return true;
+    }
+    case 9: { // tabs:tabs_af8e_TabsBridgedEngine_sync_id
+      using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>>;
+      CallHandler::CallSync(tabs_af8e_TabsBridgedEngine_sync_id, aGlobal, aArgs, aReturnValue, "tabs_af8e_TabsBridgedEngine_sync_id: "_ns, aError);
+      return true;
+    }
+    case 10: { // tabs:tabs_af8e_TabsBridgedEngine_reset_sync_id
+      using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>>;
+      CallHandler::CallSync(tabs_af8e_TabsBridgedEngine_reset_sync_id, aGlobal, aArgs, aReturnValue, "tabs_af8e_TabsBridgedEngine_reset_sync_id: "_ns, aError);
+      return true;
+    }
+    case 11: { // tabs:tabs_af8e_TabsBridgedEngine_ensure_current_sync_id
+      using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>, ScaffoldingConverter<RustBuffer>>;
+      CallHandler::CallSync(tabs_af8e_TabsBridgedEngine_ensure_current_sync_id, aGlobal, aArgs, aReturnValue, "tabs_af8e_TabsBridgedEngine_ensure_current_sync_id: "_ns, aError);
+      return true;
+    }
+    case 12: { // tabs:tabs_af8e_TabsBridgedEngine_prepare_for_sync
+      using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<void>, ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>, ScaffoldingConverter<RustBuffer>>;
+      CallHandler::CallSync(tabs_af8e_TabsBridgedEngine_prepare_for_sync, aGlobal, aArgs, aReturnValue, "tabs_af8e_TabsBridgedEngine_prepare_for_sync: "_ns, aError);
+      return true;
+    }
+    case 13: { // tabs:tabs_af8e_TabsBridgedEngine_sync_started
+      using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<void>, ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>>;
+      CallHandler::CallSync(tabs_af8e_TabsBridgedEngine_sync_started, aGlobal, aArgs, aReturnValue, "tabs_af8e_TabsBridgedEngine_sync_started: "_ns, aError);
+      return true;
+    }
+    case 14: { // tabs:tabs_af8e_TabsBridgedEngine_store_incoming
+      using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<void>, ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>, ScaffoldingConverter<RustBuffer>>;
+      CallHandler::CallSync(tabs_af8e_TabsBridgedEngine_store_incoming, aGlobal, aArgs, aReturnValue, "tabs_af8e_TabsBridgedEngine_store_incoming: "_ns, aError);
+      return true;
+    }
+    case 15: { // tabs:tabs_af8e_TabsBridgedEngine_apply
+      using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>>;
+      CallHandler::CallSync(tabs_af8e_TabsBridgedEngine_apply, aGlobal, aArgs, aReturnValue, "tabs_af8e_TabsBridgedEngine_apply: "_ns, aError);
+      return true;
+    }
+    case 16: { // tabs:tabs_af8e_TabsBridgedEngine_set_uploaded
+      using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<void>, ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>, ScaffoldingConverter<int64_t>, ScaffoldingConverter<RustBuffer>>;
+      CallHandler::CallSync(tabs_af8e_TabsBridgedEngine_set_uploaded, aGlobal, aArgs, aReturnValue, "tabs_af8e_TabsBridgedEngine_set_uploaded: "_ns, aError);
+      return true;
+    }
+    case 17: { // tabs:tabs_af8e_TabsBridgedEngine_sync_finished
+      using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<void>, ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>>;
+      CallHandler::CallSync(tabs_af8e_TabsBridgedEngine_sync_finished, aGlobal, aArgs, aReturnValue, "tabs_af8e_TabsBridgedEngine_sync_finished: "_ns, aError);
+      return true;
+    }
+    case 18: { // tabs:tabs_af8e_TabsBridgedEngine_reset
+      using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<void>, ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>>;
+      CallHandler::CallSync(tabs_af8e_TabsBridgedEngine_reset, aGlobal, aArgs, aReturnValue, "tabs_af8e_TabsBridgedEngine_reset: "_ns, aError);
+      return true;
+    }
+    case 19: { // tabs:tabs_af8e_TabsBridgedEngine_wipe
+      using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<void>, ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>>;
+      CallHandler::CallSync(tabs_af8e_TabsBridgedEngine_wipe, aGlobal, aArgs, aReturnValue, "tabs_af8e_TabsBridgedEngine_wipe: "_ns, aError);
+      return true;
+    }
+  }
+  return false;
+}
+
+Maybe<already_AddRefed<UniFFIPointer>> UniFFIReadPointer(const GlobalObject& aGlobal, uint64_t aId, const ArrayBuffer& aArrayBuff, long aPosition, ErrorResult& aError) {
+  const UniFFIPointerType* type;
+  switch (aId) {
+    case 0: { // tabs:TabsStore
+      type = &kTabsTabsStorePointerType;
+      break;
+    }
+    case 1: { // tabs:TabsBridgedEngine
+      type = &kTabsTabsBridgedEnginePointerType;
+      break;
+    }
+    default:
+      return Nothing();
+  }
+  return Some(UniFFIPointer::Read(aArrayBuff, aPosition, type, aError));
+}
+
+bool UniFFIWritePointer(const GlobalObject& aGlobal, uint64_t aId, const UniFFIPointer& aPtr, const ArrayBuffer& aArrayBuff, long aPosition, ErrorResult& aError) {
+  const UniFFIPointerType* type;
+  switch (aId) {
+    case 0: { // tabs:TabsStore
+      type = &kTabsTabsStorePointerType;
+      break;
+    }
+    case 1: { // tabs:TabsBridgedEngine
+      type = &kTabsTabsBridgedEnginePointerType;
+      break;
+    }
+    default:
+      return false;
+  }
+  aPtr.Write(aArrayBuff, aPosition, type, aError);
+  return true;
+}
+
+}  // namespace mozilla::uniffi