Fri Dec 16 04:46:51 UTC 202220221216044651

d/help2man-1.49.3-x86_64-1.txz:  Upgraded.
l/pipewire-0.3.63-x86_64-1.txz:  Upgraded.
x/libX11-1.8.3-x86_64-1.txz:  Upgraded.
x/mesa-22.3.1-x86_64-1.txz:  Upgraded.
xap/mozilla-firefox-108.0-x86_64-1.txz:  Upgraded.
  This update contains security fixes and improvements.
  Thanks to marav for the build help.
  For more information, see:
    https://www.mozilla.org/en-US/firefox/108.0/releasenotes/
    https://www.mozilla.org/en-US/security/advisories/mfsa2022-51/
    https://www.cve.org/CVERecord?id=CVE-2022-46871
    https://www.cve.org/CVERecord?id=CVE-2022-46872
    https://www.cve.org/CVERecord?id=CVE-2022-46873
    https://www.cve.org/CVERecord?id=CVE-2022-46874
    https://www.cve.org/CVERecord?id=CVE-2022-46875
    https://www.cve.org/CVERecord?id=CVE-2022-46877
    https://www.cve.org/CVERecord?id=CVE-2022-46878
    https://www.cve.org/CVERecord?id=CVE-2022-46879
  (* Security fix *)

4 files changed, 3584 insertions, 41 deletions

diff --git a/source/xap/mozilla-firefox/8f889cf198ae7ffa9341423cb5a07ed39c07463a.patch b/source/xap/mozilla-firefox/8f889cf198ae7ffa9341423cb5a07ed39c07463a.patch
new file mode 100644
index 000000000..89e7c12b8
--- /dev/null
+++ b/source/xap/mozilla-firefox/8f889cf198ae7ffa9341423cb5a07ed39c07463a.patch
@@ -0,0 +1,801 @@
+From 8f889cf198ae7ffa9341423cb5a07ed39c07463a Mon Sep 17 00:00:00 2001
+From: Mike Hommey <mh@glandium.org>
+Date: Thu, 15 Dec 2022 16:36:52 +0900
+Subject: [PATCH] Replace the use of Hash with a custom trait
+
+The custom trait is expected to consistently give the result that Hash
+gives on 64-bits little-endian, but on all platforms
+---
+ uniffi_bindgen/src/interface/attributes.rs |  19 ++--
+ uniffi_bindgen/src/interface/callbacks.rs  |  11 +-
+ uniffi_bindgen/src/interface/enum_.rs      |   5 +-
+ uniffi_bindgen/src/interface/error.rs      |   3 +-
+ uniffi_bindgen/src/interface/function.rs   |  17 ++--
+ uniffi_bindgen/src/interface/literal.rs    |  11 +-
+ uniffi_bindgen/src/interface/mod.rs        |  28 +++---
+ uniffi_bindgen/src/interface/object.rs     |  37 +++----
+ uniffi_bindgen/src/interface/record.rs     |   5 +-
+ uniffi_bindgen/src/interface/types/mod.rs  |   3 +-
+ uniffi_checksum_derive/Cargo.toml          |  22 ++++
+ uniffi_checksum_derive/src/lib.rs          | 111 +++++++++++++++++++++
+ uniffi_meta/Cargo.toml                     |   1 +
+ uniffi_meta/src/lib.rs                     |  89 +++++++++++++++--
+ 14 files changed, 288 insertions(+), 74 deletions(-)
+ create mode 100644 uniffi_checksum_derive/Cargo.toml
+ create mode 100644 uniffi_checksum_derive/src/lib.rs
+
+diff --git a/uniffi_bindgen/src/interface/attributes.rs b/uniffi_bindgen/src/interface/attributes.rs
+index 49b885520..3c9bd522b 100644
+--- a/uniffi_bindgen/src/interface/attributes.rs
++++ b/uniffi_bindgen/src/interface/attributes.rs
+@@ -15,13 +15,14 @@
+ //! if we grow significantly more complicated attribute handling.
+ 
+ use anyhow::{bail, Result};
++use uniffi_meta::Checksum;
+ 
+ /// Represents an attribute parsed from UDL, like `[ByRef]` or `[Throws]`.
+ ///
+ /// This is a convenience enum for parsing UDL attributes and erroring out if we encounter
+ /// any unsupported ones. These don't convert directly into parts of a `ComponentInterface`, but
+ /// may influence the properties of things like functions and arguments.
+-#[derive(Debug, Clone, Hash)]
++#[derive(Debug, Clone, Checksum)]
+ pub(super) enum Attribute {
+     ByRef,
+     Enum,
+@@ -119,7 +120,7 @@ where
+ 
+ /// Attributes that can be attached to an `enum` definition in the UDL.
+ /// There's only one case here: using `[Error]` to mark an enum as an error class.
+-#[derive(Debug, Clone, Hash, Default)]
++#[derive(Debug, Clone, Checksum, Default)]
+ pub(super) struct EnumAttributes(Vec<Attribute>);
+ 
+ impl EnumAttributes {
+@@ -155,7 +156,7 @@ impl<T: TryInto<EnumAttributes, Error = anyhow::Error>> TryFrom<Option<T>> for E
+ ///
+ /// This supports the `[Throws=ErrorName]` attribute for functions that
+ /// can produce an error.
+-#[derive(Debug, Clone, Hash, Default)]
++#[derive(Debug, Clone, Checksum, Default)]
+ pub(super) struct FunctionAttributes(Vec<Attribute>);
+ 
+ impl FunctionAttributes {
+@@ -198,7 +199,7 @@ impl<T: TryInto<FunctionAttributes, Error = anyhow::Error>> TryFrom<Option<T>>
+ ///
+ /// This supports the `[ByRef]` attribute for arguments that should be passed
+ /// by reference in the generated Rust scaffolding.
+-#[derive(Debug, Clone, Hash, Default)]
++#[derive(Debug, Clone, Checksum, Default)]
+ pub(super) struct ArgumentAttributes(Vec<Attribute>);
+ 
+ impl ArgumentAttributes {
+@@ -233,7 +234,7 @@ impl<T: TryInto<ArgumentAttributes, Error = anyhow::Error>> TryFrom<Option<T>>
+ }
+ 
+ /// Represents UDL attributes that might appear on an `interface` definition.
+-#[derive(Debug, Clone, Hash, Default)]
++#[derive(Debug, Clone, Checksum, Default)]
+ pub(super) struct InterfaceAttributes(Vec<Attribute>);
+ 
+ impl InterfaceAttributes {
+@@ -287,7 +288,7 @@ impl<T: TryInto<InterfaceAttributes, Error = anyhow::Error>> TryFrom<Option<T>>
+ ///
+ /// This supports the `[Throws=ErrorName]` attribute for constructors that can produce
+ /// an error, and the `[Name=MethodName]` for non-default constructors.
+-#[derive(Debug, Clone, Hash, Default)]
++#[derive(Debug, Clone, Checksum, Default)]
+ pub(super) struct ConstructorAttributes(Vec<Attribute>);
+ 
+ impl ConstructorAttributes {
+@@ -326,7 +327,7 @@ impl TryFrom<&weedle::attribute::ExtendedAttributeList<'_>> for ConstructorAttri
+ ///
+ /// This supports the `[Throws=ErrorName]` attribute for methods that can produce
+ /// an error, and the `[Self=ByArc]` attribute for methods that take `Arc<Self>` as receiver.
+-#[derive(Debug, Clone, Hash, Default)]
++#[derive(Debug, Clone, Checksum, Default)]
+ pub(super) struct MethodAttributes(Vec<Attribute>);
+ 
+ impl MethodAttributes {
+@@ -375,7 +376,7 @@ impl<T: TryInto<MethodAttributes, Error = anyhow::Error>> TryFrom<Option<T>> for
+ /// Actually we only support one of these right now, `[Self=ByArc]`.
+ /// We might add more in future, e.g. a `[Self=ByRef]` if there are cases
+ /// where we need to force the receiver to be taken by reference.
+-#[derive(Debug, Clone, Hash)]
++#[derive(Debug, Clone, Checksum)]
+ pub(super) enum SelfType {
+     ByArc, // Method receiver is `Arc<Self>`.
+ }
+@@ -398,7 +399,7 @@ impl TryFrom<&weedle::attribute::IdentifierOrString<'_>> for SelfType {
+ /// Represents UDL attributes that might appear on a typedef
+ ///
+ /// This supports the `[External="crate_name"]` and `[Custom]` attributes for types.
+-#[derive(Debug, Clone, Hash, Default)]
++#[derive(Debug, Clone, Checksum, Default)]
+ pub(super) struct TypedefAttributes(Vec<Attribute>);
+ 
+ impl TypedefAttributes {
+diff --git a/uniffi_bindgen/src/interface/callbacks.rs b/uniffi_bindgen/src/interface/callbacks.rs
+index 654652afe..886f02b29 100644
+--- a/uniffi_bindgen/src/interface/callbacks.rs
++++ b/uniffi_bindgen/src/interface/callbacks.rs
+@@ -33,9 +33,10 @@
+ //! # Ok::<(), anyhow::Error>(())
+ //! ```
+ 
+-use std::hash::{Hash, Hasher};
++use std::hash::Hasher;
+ 
+ use anyhow::{bail, Result};
++use uniffi_meta::Checksum;
+ 
+ use super::ffi::{FFIArgument, FFIFunction, FFIType};
+ use super::object::Method;
+@@ -88,16 +89,16 @@ impl CallbackInterface {
+     }
+ }
+ 
+-impl Hash for CallbackInterface {
+-    fn hash<H: Hasher>(&self, state: &mut H) {
++impl Checksum for CallbackInterface {
++    fn checksum<H: Hasher>(&self, state: &mut H) {
+         // We don't include the FFIFunc in the hash calculation, because:
+         //  - it is entirely determined by the other fields,
+         //    so excluding it is safe.
+         //  - its `name` property includes a checksum derived from  the very
+         //    hash value we're trying to calculate here, so excluding it
+         //    avoids a weird circular depenendency in the calculation.
+-        self.name.hash(state);
+-        self.methods.hash(state);
++        self.name.checksum(state);
++        self.methods.checksum(state);
+     }
+ }
+ 
+diff --git a/uniffi_bindgen/src/interface/enum_.rs b/uniffi_bindgen/src/interface/enum_.rs
+index 04eba0d25..b8fe0ddd7 100644
+--- a/uniffi_bindgen/src/interface/enum_.rs
++++ b/uniffi_bindgen/src/interface/enum_.rs
+@@ -77,6 +77,7 @@
+ //! ```
+ 
+ use anyhow::{bail, Result};
++use uniffi_meta::Checksum;
+ 
+ use super::record::Field;
+ use super::types::{Type, TypeIterator};
+@@ -87,7 +88,7 @@ use super::{APIConverter, ComponentInterface};
+ ///
+ /// Enums are passed across the FFI by serializing to a bytebuffer, with a
+ /// i32 indicating the variant followed by the serialization of each field.
+-#[derive(Debug, Clone, Hash)]
++#[derive(Debug, Clone, Checksum)]
+ pub struct Enum {
+     pub(super) name: String,
+     pub(super) variants: Vec<Variant>,
+@@ -174,7 +175,7 @@ impl APIConverter<Enum> for weedle::InterfaceDefinition<'_> {
+ /// Represents an individual variant in an Enum.
+ ///
+ /// Each variant has a name and zero or more fields.
+-#[derive(Debug, Clone, Default, Hash)]
++#[derive(Debug, Clone, Default, Checksum)]
+ pub struct Variant {
+     pub(super) name: String,
+     pub(super) fields: Vec<Field>,
+diff --git a/uniffi_bindgen/src/interface/error.rs b/uniffi_bindgen/src/interface/error.rs
+index 7e9b571a1..adae769f0 100644
+--- a/uniffi_bindgen/src/interface/error.rs
++++ b/uniffi_bindgen/src/interface/error.rs
+@@ -83,6 +83,7 @@
+ //! ```
+ 
+ use anyhow::Result;
++use uniffi_meta::Checksum;
+ 
+ use super::enum_::{Enum, Variant};
+ use super::types::{Type, TypeIterator};
+@@ -94,7 +95,7 @@ use super::{APIConverter, ComponentInterface};
+ /// they're handled in the FFI very differently. We create them in `uniffi::call_with_result()` if
+ /// the wrapped function returns an `Err` value
+ /// struct and assign an integer error code to each variant.
+-#[derive(Debug, Clone, Hash)]
++#[derive(Debug, Clone, Checksum)]
+ pub struct Error {
+     pub name: String,
+     enum_: Enum,
+diff --git a/uniffi_bindgen/src/interface/function.rs b/uniffi_bindgen/src/interface/function.rs
+index 4eff0795c..869c1b59b 100644
+--- a/uniffi_bindgen/src/interface/function.rs
++++ b/uniffi_bindgen/src/interface/function.rs
+@@ -32,9 +32,10 @@
+ //! # Ok::<(), anyhow::Error>(())
+ //! ```
+ use std::convert::TryFrom;
+-use std::hash::{Hash, Hasher};
++use std::hash::Hasher;
+ 
+ use anyhow::{bail, Result};
++use uniffi_meta::Checksum;
+ 
+ use super::ffi::{FFIArgument, FFIFunction};
+ use super::literal::{convert_default_value, Literal};
+@@ -142,18 +143,18 @@ impl From<uniffi_meta::FnMetadata> for Function {
+     }
+ }
+ 
+-impl Hash for Function {
+-    fn hash<H: Hasher>(&self, state: &mut H) {
++impl Checksum for Function {
++    fn checksum<H: Hasher>(&self, state: &mut H) {
+         // We don't include the FFIFunc in the hash calculation, because:
+         //  - it is entirely determined by the other fields,
+         //    so excluding it is safe.
+         //  - its `name` property includes a checksum derived from  the very
+         //    hash value we're trying to calculate here, so excluding it
+         //    avoids a weird circular depenendency in the calculation.
+-        self.name.hash(state);
+-        self.arguments.hash(state);
+-        self.return_type.hash(state);
+-        self.attributes.hash(state);
++        self.name.checksum(state);
++        self.arguments.checksum(state);
++        self.return_type.checksum(state);
++        self.attributes.checksum(state);
+     }
+ }
+ 
+@@ -185,7 +186,7 @@ impl APIConverter<Function> for weedle::namespace::OperationNamespaceMember<'_>
+ /// Represents an argument to a function/constructor/method call.
+ ///
+ /// Each argument has a name and a type, along with some optional metadata.
+-#[derive(Debug, Clone, Hash)]
++#[derive(Debug, Clone, Checksum)]
+ pub struct Argument {
+     pub(super) name: String,
+     pub(super) type_: Type,
+diff --git a/uniffi_bindgen/src/interface/literal.rs b/uniffi_bindgen/src/interface/literal.rs
+index 8b333c614..1aa1c8785 100644
+--- a/uniffi_bindgen/src/interface/literal.rs
++++ b/uniffi_bindgen/src/interface/literal.rs
+@@ -8,12 +8,13 @@
+ //! which appear in places such as default arguments.
+ 
+ use anyhow::{bail, Result};
++use uniffi_meta::Checksum;
+ 
+ use super::types::Type;
+ 
+ // Represents a literal value.
+ // Used for e.g. default argument values.
+-#[derive(Debug, Clone, Hash)]
++#[derive(Debug, Clone, Checksum)]
+ pub enum Literal {
+     Boolean(bool),
+     String(String),
+@@ -35,13 +36,19 @@ pub enum Literal {
+ 
+ // Represent the radix of integer literal values.
+ // We preserve the radix into the generated bindings for readability reasons.
+-#[derive(Debug, Clone, Copy, Hash)]
++#[derive(Debug, Clone, Copy)]
+ pub enum Radix {
+     Decimal = 10,
+     Octal = 8,
+     Hexadecimal = 16,
+ }
+ 
++impl Checksum for Radix {
++    fn checksum<H: ::core::hash::Hasher>(&self, state: &mut H) {
++        state.write(&(*self as u64).to_le_bytes());
++    }
++}
++
+ pub(super) fn convert_default_value(
+     default_value: &weedle::literal::DefaultValue<'_>,
+     type_: &Type,
+diff --git a/uniffi_bindgen/src/interface/mod.rs b/uniffi_bindgen/src/interface/mod.rs
+index 9aa92e9b0..eb40ea3fd 100644
+--- a/uniffi_bindgen/src/interface/mod.rs
++++ b/uniffi_bindgen/src/interface/mod.rs
+@@ -47,7 +47,7 @@
+ use std::{
+     collections::HashSet,
+     convert::TryFrom,
+-    hash::{Hash, Hasher},
++    hash::Hasher,
+     iter,
+ };
+ 
+@@ -77,7 +77,7 @@ pub use record::{Field, Record};
+ 
+ pub mod ffi;
+ pub use ffi::{FFIArgument, FFIFunction, FFIType};
+-use uniffi_meta::{MethodMetadata, ObjectMetadata};
++use uniffi_meta::{Checksum, MethodMetadata, ObjectMetadata};
+ 
+ /// The main public interface for this module, representing the complete details of an interface exposed
+ /// by a rust component and the details of consuming it via an extern-C FFI layer.
+@@ -672,20 +672,16 @@ impl ComponentInterface {
+     }
+ }
+ 
+-/// `ComponentInterface` structs can be hashed, but this is mostly a convenient way to
+-/// produce a checksum of their contents. They're not really intended to live in a hashtable.
+-impl Hash for ComponentInterface {
+-    fn hash<H: Hasher>(&self, state: &mut H) {
+-        // We can't hash `self.types`, but its contents are implied by the other fields
+-        // anyway, so it's safe to ignore it.
+-        self.uniffi_version.hash(state);
+-        self.namespace.hash(state);
+-        self.enums.hash(state);
+-        self.records.hash(state);
+-        self.functions.hash(state);
+-        self.objects.hash(state);
+-        self.callback_interfaces.hash(state);
+-        self.errors.hash(state);
++impl Checksum for ComponentInterface {
++    fn checksum<H: Hasher>(&self, state: &mut H) {
++        Checksum::checksum(&self.uniffi_version, state);
++        Checksum::checksum(&self.namespace, state);
++        Checksum::checksum(&self.enums, state);
++        Checksum::checksum(&self.records, state);
++        Checksum::checksum(&self.functions, state);
++        Checksum::checksum(&self.objects, state);
++        Checksum::checksum(&self.callback_interfaces, state);
++        Checksum::checksum(&self.errors, state);
+     }
+ }
+ 
+diff --git a/uniffi_bindgen/src/interface/object.rs b/uniffi_bindgen/src/interface/object.rs
+index e366123b5..3bd6bfabe 100644
+--- a/uniffi_bindgen/src/interface/object.rs
++++ b/uniffi_bindgen/src/interface/object.rs
+@@ -58,10 +58,11 @@
+ //! ```
+ 
+ use std::convert::TryFrom;
+-use std::hash::{Hash, Hasher};
++use std::hash::Hasher;
+ use std::{collections::HashSet, iter};
+ 
+ use anyhow::{bail, Result};
++use uniffi_meta::Checksum;
+ 
+ use super::ffi::{FFIArgument, FFIFunction, FFIType};
+ use super::function::Argument;
+@@ -190,17 +191,17 @@ impl Object {
+     }
+ }
+ 
+-impl Hash for Object {
+-    fn hash<H: Hasher>(&self, state: &mut H) {
++impl Checksum for Object {
++    fn checksum<H: Hasher>(&self, state: &mut H) {
+         // We don't include the FFIFunc in the hash calculation, because:
+         //  - it is entirely determined by the other fields,
+         //    so excluding it is safe.
+         //  - its `name` property includes a checksum derived from  the very
+         //    hash value we're trying to calculate here, so excluding it
+         //    avoids a weird circular depenendency in the calculation.
+-        self.name.hash(state);
+-        self.constructors.hash(state);
+-        self.methods.hash(state);
++        self.name.checksum(state);
++        self.constructors.checksum(state);
++        self.methods.checksum(state);
+     }
+ }
+ 
+@@ -299,17 +300,17 @@ impl Constructor {
+     }
+ }
+ 
+-impl Hash for Constructor {
+-    fn hash<H: Hasher>(&self, state: &mut H) {
++impl Checksum for Constructor {
++    fn checksum<H: Hasher>(&self, state: &mut H) {
+         // We don't include the FFIFunc in the hash calculation, because:
+         //  - it is entirely determined by the other fields,
+         //    so excluding it is safe.
+         //  - its `name` property includes a checksum derived from  the very
+         //    hash value we're trying to calculate here, so excluding it
+         //    avoids a weird circular depenendency in the calculation.
+-        self.name.hash(state);
+-        self.arguments.hash(state);
+-        self.attributes.hash(state);
++        self.name.checksum(state);
++        self.arguments.checksum(state);
++        self.attributes.checksum(state);
+     }
+ }
+ 
+@@ -450,19 +451,19 @@ impl From<uniffi_meta::MethodMetadata> for Method {
+     }
+ }
+ 
+-impl Hash for Method {
+-    fn hash<H: Hasher>(&self, state: &mut H) {
++impl Checksum for Method {
++    fn checksum<H: Hasher>(&self, state: &mut H) {
+         // We don't include the FFIFunc in the hash calculation, because:
+         //  - it is entirely determined by the other fields,
+         //    so excluding it is safe.
+         //  - its `name` property includes a checksum derived from  the very
+         //    hash value we're trying to calculate here, so excluding it
+         //    avoids a weird circular depenendency in the calculation.
+-        self.name.hash(state);
+-        self.object_name.hash(state);
+-        self.arguments.hash(state);
+-        self.return_type.hash(state);
+-        self.attributes.hash(state);
++        self.name.checksum(state);
++        self.object_name.checksum(state);
++        self.arguments.checksum(state);
++        self.return_type.checksum(state);
++        self.attributes.checksum(state);
+     }
+ }
+ 
+diff --git a/uniffi_bindgen/src/interface/record.rs b/uniffi_bindgen/src/interface/record.rs
+index c55200eb1..dd6a48e2c 100644
+--- a/uniffi_bindgen/src/interface/record.rs
++++ b/uniffi_bindgen/src/interface/record.rs
+@@ -45,6 +45,7 @@
+ //! ```
+ 
+ use anyhow::{bail, Result};
++use uniffi_meta::Checksum;
+ 
+ use super::types::{Type, TypeIterator};
+ use super::{
+@@ -58,7 +59,7 @@ use super::{APIConverter, ComponentInterface};
+ /// In the FFI these are represented as a byte buffer, which one side explicitly
+ /// serializes the data into and the other serializes it out of. So I guess they're
+ /// kind of like "pass by clone" values.
+-#[derive(Debug, Clone, Hash)]
++#[derive(Debug, Clone, Checksum)]
+ pub struct Record {
+     pub(super) name: String,
+     pub(super) fields: Vec<Field>,
+@@ -109,7 +110,7 @@ impl APIConverter<Record> for weedle::DictionaryDefinition<'_> {
+ }
+ 
+ // Represents an individual field on a Record.
+-#[derive(Debug, Clone, Hash)]
++#[derive(Debug, Clone, Checksum)]
+ pub struct Field {
+     pub(super) name: String,
+     pub(super) type_: Type,
+diff --git a/uniffi_bindgen/src/interface/types/mod.rs b/uniffi_bindgen/src/interface/types/mod.rs
+index 8a0131c9f..65426926f 100644
+--- a/uniffi_bindgen/src/interface/types/mod.rs
++++ b/uniffi_bindgen/src/interface/types/mod.rs
+@@ -25,6 +25,7 @@ use std::{collections::hash_map::Entry, collections::BTreeSet, collections::Hash
+ 
+ use anyhow::{bail, Result};
+ use heck::ToUpperCamelCase;
++use uniffi_meta::Checksum;
+ 
+ use super::ffi::FFIType;
+ 
+@@ -36,7 +37,7 @@ pub(super) use resolver::{resolve_builtin_type, TypeResolver};
+ /// Represents all the different high-level types that can be used in a component interface.
+ /// At this level we identify user-defined types by name, without knowing any details
+ /// of their internal structure apart from what type of thing they are (record, enum, etc).
+-#[derive(Debug, Clone, Eq, PartialEq, Hash, Ord, PartialOrd)]
++#[derive(Debug, Clone, Eq, PartialEq, Checksum, Ord, PartialOrd)]
+ pub enum Type {
+     // Primitive types.
+     UInt8,
+diff --git a/uniffi_checksum_derive/Cargo.toml b/uniffi_checksum_derive/Cargo.toml
+new file mode 100644
+index 000000000..a04c31aab
+--- /dev/null
++++ b/uniffi_checksum_derive/Cargo.toml
+@@ -0,0 +1,22 @@
++[package]
++name = "uniffi_checksum_derive"
++version = "0.21.0"
++authors = ["Firefox Sync Team <sync-team@mozilla.com>"]
++description = "a multi-language bindings generator for rust (checksum custom derive)"
++documentation = "https://mozilla.github.io/uniffi-rs"
++homepage = "https://mozilla.github.io/uniffi-rs"
++repository = "https://github.com/mozilla/uniffi-rs"
++license = "MPL-2.0"
++edition = "2021"
++keywords = ["ffi", "bindgen"]
++
++[lib]
++proc-macro = true
++
++[dependencies]
++quote = "1.0"
++syn = { version = "1.0", features = ["derive"] }
++
++[features]
++default = []
++nightly = []
+diff --git a/uniffi_checksum_derive/src/lib.rs b/uniffi_checksum_derive/src/lib.rs
+new file mode 100644
+index 000000000..c79064d8b
+--- /dev/null
++++ b/uniffi_checksum_derive/src/lib.rs
+@@ -0,0 +1,111 @@
++/* This Source Code Form is subject to the terms of the Mozilla Public
++ * License, v. 2.0. If a copy of the MPL was not distributed with this
++ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
++#![cfg_attr(feature = "nightly", feature(proc_macro_expand))]
++
++//! Custom derive for uniffi_meta::Checksum
++
++use proc_macro::TokenStream;
++use quote::{format_ident, quote};
++use syn::{parse_macro_input, Data, DeriveInput, Fields, Index};
++
++#[proc_macro_derive(Checksum)]
++pub fn checksum_derive(input: TokenStream) -> TokenStream {
++    let input: DeriveInput = parse_macro_input!(input);
++
++    let name = input.ident;
++
++    let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();
++
++    let code = match input.data {
++        Data::Enum(enum_)
++            if enum_.variants.len() == 1
++                && enum_
++                    .variants
++                    .iter()
++                    .all(|variant| matches!(variant.fields, Fields::Unit)) =>
++        {
++            quote!()
++        }
++        Data::Enum(enum_) => {
++            let match_inner = enum_.variants.iter().enumerate().map(|(num, variant)| {
++                let num = num as u64;
++                let ident = &variant.ident;
++                if variant.discriminant.is_some() {
++                    panic!("#[derive(Checksum)] doesn't support explicit discriminants in enums");
++                }
++                let discriminant = quote! { state.write(&#num.to_le_bytes()) };
++                match &variant.fields {
++                    Fields::Unnamed(fields) => {
++                        let field_idents = fields
++                            .unnamed
++                            .iter()
++                            .enumerate()
++                            .map(|(num, _)| format_ident!("__self_{}", num))
++                            .collect::<Vec<_>>();
++                        let field_stmts = field_idents
++                            .iter()
++                            .map(|ident| quote! { Checksum::checksum(#ident, state); });
++                        quote! {
++                            Self::#ident(#(#field_idents,)*) => {
++                                #discriminant;
++                                #(#field_stmts)*
++                            }
++                        }
++                    }
++                    Fields::Named(fields) => {
++                        let field_idents = fields
++                            .named
++                            .iter()
++                            .map(|field| field.ident.as_ref().unwrap())
++                            .collect::<Vec<_>>();
++                        let field_stmts = field_idents
++                            .iter()
++                            .map(|ident| quote! { Checksum::checksum(#ident, state); });
++                        quote! {
++                            Self::#ident { #(#field_idents,)* } => {
++                                #discriminant;
++                                #(#field_stmts)*
++                            }
++                        }
++                    }
++                    Fields::Unit => quote! { Self::#ident => #discriminant, },
++                }
++            });
++            quote! {
++                match self {
++                    #(#match_inner)*
++                }
++            }
++        }
++        Data::Struct(struct_) => {
++            let stmts =
++                struct_
++                    .fields
++                    .iter()
++                    .enumerate()
++                    .map(|(num, field)| match field.ident.as_ref() {
++                        Some(ident) => quote! { Checksum::checksum(&self.#ident, state); },
++                        None => {
++                            let i = Index::from(num);
++                            quote! { Checksum::checksum(&self.#i, state); }
++                        }
++                    });
++            quote! {
++                #(#stmts)*
++            }
++        }
++        Data::Union(_) => {
++            panic!("#[derive(Checksum)] is not supported for unions");
++        }
++    };
++
++    quote! {
++        impl #impl_generics Checksum for #name #ty_generics #where_clause {
++            fn checksum<__H: ::core::hash::Hasher>(&self, state: &mut __H) {
++                #code
++            }
++        }
++    }
++    .into()
++}
+diff --git a/uniffi_meta/Cargo.toml b/uniffi_meta/Cargo.toml
+index ca33156df..358b6ef4c 100644
+--- a/uniffi_meta/Cargo.toml
++++ b/uniffi_meta/Cargo.toml
+@@ -10,3 +10,4 @@ keywords = ["ffi", "bindgen"]
+ 
+ [dependencies]
+ serde = { version = "1.0.136", features = ["derive"] }
++uniffi_checksum_derive = { version = "0.21.0", path = "../uniffi_checksum_derive" }
+diff --git a/uniffi_meta/src/lib.rs b/uniffi_meta/src/lib.rs
+index 6cfa733e9..2555ae19c 100644
+--- a/uniffi_meta/src/lib.rs
++++ b/uniffi_meta/src/lib.rs
+@@ -6,10 +6,79 @@ use std::{
+     collections::hash_map::DefaultHasher,
+     hash::{Hash, Hasher},
+ };
++pub use uniffi_checksum_derive::Checksum;
+ 
+ use serde::{Deserialize, Serialize};
+ 
+-#[derive(Clone, Debug, Hash, Deserialize, Serialize)]
++pub trait Checksum {
++    fn checksum<H: Hasher>(&self, state: &mut H);
++}
++
++impl Checksum for bool {
++    fn checksum<H: Hasher>(&self, state: &mut H) {
++        Hash::hash(self, state);
++    }
++}
++
++impl Checksum for u64 {
++    fn checksum<H: Hasher>(&self, state: &mut H) {
++        state.write(&self.to_le_bytes());
++    }
++}
++
++impl Checksum for i64 {
++    fn checksum<H: Hasher>(&self, state: &mut H) {
++        state.write(&self.to_le_bytes());
++    }
++}
++
++impl<T: Checksum> Checksum for Box<T> {
++    fn checksum<H: Hasher>(&self, state: &mut H) {
++        (**self).checksum(state)
++    }
++}
++
++impl<T: Checksum> Checksum for [T] {
++    fn checksum<H: Hasher>(&self, state: &mut H) {
++        state.write(&(self.len() as u64).to_le_bytes());
++        for item in self {
++            Checksum::checksum(item, state);
++        }
++    }
++}
++
++impl<T: Checksum> Checksum for Vec<T> {
++    fn checksum<H: Hasher>(&self, state: &mut H) {
++        Checksum::checksum(&**self, state);
++    }
++}
++
++impl<T: Checksum> Checksum for Option<T> {
++    fn checksum<H: Hasher>(&self, state: &mut H) {
++        match self {
++            None => state.write(&0u64.to_le_bytes()),
++            Some(value) => {
++                state.write(&1u64.to_le_bytes());
++                Checksum::checksum(value, state)
++            }
++        }
++    }
++}
++
++impl Checksum for str {
++    fn checksum<H: Hasher>(&self, state: &mut H) {
++        state.write(self.as_bytes());
++        state.write_u8(0xff);
++    }
++}
++
++impl Checksum for String {
++    fn checksum<H: Hasher>(&self, state: &mut H) {
++        (**self).checksum(state)
++    }
++}
++
++#[derive(Clone, Debug, Checksum, Deserialize, Serialize)]
+ pub struct FnMetadata {
+     pub module_path: Vec<String>,
+     pub name: String,
+@@ -23,7 +92,7 @@ impl FnMetadata {
+     }
+ }
+ 
+-#[derive(Clone, Debug, Hash, Deserialize, Serialize)]
++#[derive(Clone, Debug, Checksum, Deserialize, Serialize)]
+ pub struct MethodMetadata {
+     pub module_path: Vec<String>,
+     pub self_name: String,
+@@ -39,14 +108,14 @@ impl MethodMetadata {
+     }
+ }
+ 
+-#[derive(Clone, Debug, Hash, Deserialize, Serialize)]
++#[derive(Clone, Debug, Checksum, Deserialize, Serialize)]
+ pub struct FnParamMetadata {
+     pub name: String,
+     #[serde(rename = "type")]
+     pub ty: Type,
+ }
+ 
+-#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Deserialize, Serialize)]
++#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Checksum, Deserialize, Serialize)]
+ pub enum Type {
+     U8,
+     U16,
+@@ -78,21 +147,21 @@ pub enum Type {
+     },
+ }
+ 
+-#[derive(Clone, Debug, Hash, Deserialize, Serialize)]
++#[derive(Clone, Debug, Checksum, Deserialize, Serialize)]
+ pub struct RecordMetadata {
+     pub module_path: Vec<String>,
+     pub name: String,
+     pub fields: Vec<FieldMetadata>,
+ }
+ 
+-#[derive(Clone, Debug, Hash, Deserialize, Serialize)]
++#[derive(Clone, Debug, Checksum, Deserialize, Serialize)]
+ pub struct FieldMetadata {
+     pub name: String,
+     #[serde(rename = "type")]
+     pub ty: Type,
+ }
+ 
+-#[derive(Clone, Debug, Hash, Deserialize, Serialize)]
++#[derive(Clone, Debug, Checksum, Deserialize, Serialize)]
+ pub struct ObjectMetadata {
+     pub module_path: Vec<String>,
+     pub name: String,
+@@ -112,9 +181,9 @@ impl ObjectMetadata {
+ ///
+ /// To be used as a checksum of FFI symbols, as a safeguard against different UniFFI versions being
+ /// used for scaffolding and bindings generation.
+-pub fn checksum<T: Hash>(val: &T) -> u16 {
++pub fn checksum<T: Checksum>(val: &T) -> u16 {
+     let mut hasher = DefaultHasher::new();
+-    val.hash(&mut hasher);
++    val.checksum(&mut hasher);
+     (hasher.finish() & 0x000000000000FFFF) as u16
+ }
+ 
+@@ -124,7 +193,7 @@ pub fn fn_ffi_symbol_name(mod_path: &[String], name: &str, checksum: u16) -> Str
+ }
+ 
+ /// Enum covering all the possible metadata types
+-#[derive(Clone, Debug, Hash, Deserialize, Serialize)]
++#[derive(Clone, Debug, Checksum, Deserialize, Serialize)]
+ pub enum Metadata {
+     Func(FnMetadata),
+     Method(MethodMetadata),
diff --git a/source/xap/mozilla-firefox/mozilla-firefox.SlackBuild b/source/xap/mozilla-firefox/mozilla-firefox.SlackBuild
index 9ce487e29..6796c101f 100755
--- a/source/xap/mozilla-firefox/mozilla-firefox.SlackBuild
+++ b/source/xap/mozilla-firefox/mozilla-firefox.SlackBuild
@@ -317,6 +317,28 @@ fi
 # Add the $OPTIONS above to .mozconfig:
 for option in $OPTIONS; do echo "ac_add_options $option" >> .mozconfig; done
 
+# Patch to match ./toolkit/components/ that have been regenerated with:
+# ./mach uniffi generate
+# This works around a build failure with 108.0 on i686. It also seems to break
+# the previously working x86_64 build, so we'll only apply it for i686.
+# Hopefully we can drop this when 108.0.1 ships.
+if [ "$ARCH" = "i686" ]; then
+  zcat $CWD/regenerated-uniffi-toolkit-components.diff.gz | patch -p1 --verbose || exit 1
+fi
+
+# This is the upstream patch to fix the above issue, but unfortunately it
+# doesn't apply completely and also causes an additional crate to be downloaded
+# at build time, which won't do. I'll leave it here for reference in case
+# anyone is interested, but we'll use the above kludge instead and wait for
+# a proper fixed release from upstream for this to be correctly handled.
+#
+# [PATCH] Replace the use of Hash with a custom trait
+# The custom trait is expected to consistently give the result that Hash
+# gives on 64-bits little-endian, but on all platforms
+#( cd ./third_party/rust
+#  zcat $CWD/8f889cf198ae7ffa9341423cb5a07ed39c07463a.patch.gz | patch -p1 --verbose || exit 1
+#)
+
 # https://developer.mozilla.org/en-US/docs/Building_with_Profile-Guided_Optimization
 # Thanks to ArchLinux and Gentoo for the additional hints.
 if [ "$PGO" = "yes" ]; then
@@ -349,38 +371,25 @@ rm -rf $PKG/usr/lib${LIBDIRSUFFIX}/firefox-devel-$RELEASEVER
 # Nor these:
 rm -rf $PKG/usr/include
 
-( cd $PKG/usr/lib${LIBDIRSUFFIX}/firefox-$RELEASEVER
-  #mv defaults/profile/mimeTypes.rdf defaults/profile/mimeTypes.rdf.orig || exit 1
-  if [ -d defaults/profile ]; then
-    zcat $CWD/mimeTypes.rdf > defaults/profile/mimeTypes.rdf || exit 1
-  fi
-  # OK, this patch is useless on 7.x.  We'll float without it and see what happens.
-  # Perhaps it won't make a difference or should be worked around elsewhere.
-  #zcat $CWD/firefox.moz_plugin_path.diff.gz \
-  #  | sed -e "s#usr/lib#usr/lib${LIBDIRSUFFIX}#g" \
-  #  | patch -p1 --verbose --backup --suffix=.orig || exit 1
-  # Clean up if the above patch was successful:
-  #rm -f firefox.orig
-) || exit
+# 2022-12, COMMENTING OUT AS OBSOLETE
+#( cd $PKG/usr/lib${LIBDIRSUFFIX}/firefox
+#  #mv defaults/profile/mimeTypes.rdf defaults/profile/mimeTypes.rdf.orig || exit 1
+#  if [ -d defaults/profile ]; then
+#    zcat $CWD/mimeTypes.rdf > defaults/profile/mimeTypes.rdf || exit 1
+#  fi
+#  # OK, this patch is useless on 7.x.  We'll float without it and see what happens.
+#  # Perhaps it won't make a difference or should be worked around elsewhere.
+#  #zcat $CWD/firefox.moz_plugin_path.diff.gz \
+#  #  | sed -e "s#usr/lib#usr/lib${LIBDIRSUFFIX}#g" \
+#  #  | patch -p1 --verbose --backup --suffix=.orig || exit 1
+#  # Clean up if the above patch was successful:
+#  #rm -f firefox.orig
+#) || exit
 
 mkdir -p $PKG/usr/lib${LIBDIRSUFFIX}/mozilla/plugins
 mkdir -p $PKG/usr/share/applications
 cat $CWD/mozilla-firefox.desktop > $PKG/usr/share/applications/mozilla-firefox.desktop
 
-# These files/directories are usually created if Firefox is run as root,
-# which on many systems might (and possibly should) be never.  Therefore, if we
-# don't see them we'll put stubs in place to prevent startup errors.
-( cd $PKG/usr/lib${LIBDIRSUFFIX}/firefox-$RELEASEVER
-  if [ -d extensions/talkback\@mozilla.org ]; then
-    if [ ! -r extensions/talkback\@mozilla.org/chrome.manifest ]; then
-      echo > extensions/talkback\@mozilla.org/chrome.manifest
-    fi
-  fi
-  if [ ! -d updates ]; then
-    mkdir -p updates/0
-  fi
-)
-
 # Need some default icons in the right place:
 for i in 16 22 24 32 48 256; do
   install -m 0644 -D browser/branding/official/default${i}.png \
diff --git a/source/xap/mozilla-firefox/regenerated-uniffi-toolkit-components.diff b/source/xap/mozilla-firefox/regenerated-uniffi-toolkit-components.diff
new file mode 100644
index 000000000..f65a456c5
--- /dev/null
+++ b/source/xap/mozilla-firefox/regenerated-uniffi-toolkit-components.diff
@@ -0,0 +1,2747 @@
+Whee... here's some fun! ;-) Firefox-108.0 would not compile on 32-bit i686,
+but compiled fine on x86_64. My good friend marav provided a link to a bug
+discussion that said running ./mach uniffi generate would work around the
+problem, and indeed it does. However, that is not suitable for packaging
+since it downloads a bunch of stuff and we want the sources to be self-
+contained. The important changes seemed to land in ./toolkit/components so
+I generated a diff, and applying that prior to the build also works around
+the compile failure. 
+
+marav also proposed this minimal sed that produces the same changes:
+
+sed -i 's/4d51/1c79/g' \
+    toolkit/components/uniffi-bindgen-gecko-js/components/generated/RustTabs.jsm \
+    toolkit/components/uniffi-js/UniFFIGeneratedScaffolding.cpp
+
+However, I think we'll use this generated diff instead since it'll be more
+obvious when we no longer need it.
+
+diff -u -r --new-file firefox-108.0.orig/toolkit/components/uniffi-bindgen-gecko-js/components/generated/RustTabs.jsm firefox-108.0/toolkit/components/uniffi-bindgen-gecko-js/components/generated/RustTabs.jsm
+--- firefox-108.0.orig/toolkit/components/uniffi-bindgen-gecko-js/components/generated/RustTabs.jsm	2022-12-08 10:27:29.000000000 -0600
++++ firefox-108.0/toolkit/components/uniffi-bindgen-gecko-js/components/generated/RustTabs.jsm	2022-12-15 13:20:01.333880947 -0600
+@@ -328,7 +328,7 @@
+     const liftError = (data) => FfiConverterTypeTabsError.lift(data);
+     const functionCall = () => {
+         return UniFFIScaffolding.callAsync(
+-            7, // tabs:tabs_4d51_TabsBridgedEngine_last_sync
++            7, // tabs:tabs_1c79_TabsBridgedEngine_last_sync
+             FfiConverterTypeTabsBridgedEngine.lower(this),
+         )
+     }
+@@ -343,7 +343,7 @@
+     const functionCall = () => {
+         FfiConverterI64.checkType("lastSync", lastSync);
+         return UniFFIScaffolding.callAsync(
+-            8, // tabs:tabs_4d51_TabsBridgedEngine_set_last_sync
++            8, // tabs:tabs_1c79_TabsBridgedEngine_set_last_sync
+             FfiConverterTypeTabsBridgedEngine.lower(this),
+             FfiConverterI64.lower(lastSync),
+         )
+@@ -358,7 +358,7 @@
+     const liftError = (data) => FfiConverterTypeTabsError.lift(data);
+     const functionCall = () => {
+         return UniFFIScaffolding.callAsync(
+-            9, // tabs:tabs_4d51_TabsBridgedEngine_sync_id
++            9, // tabs:tabs_1c79_TabsBridgedEngine_sync_id
+             FfiConverterTypeTabsBridgedEngine.lower(this),
+         )
+     }
+@@ -372,7 +372,7 @@
+     const liftError = (data) => FfiConverterTypeTabsError.lift(data);
+     const functionCall = () => {
+         return UniFFIScaffolding.callAsync(
+-            10, // tabs:tabs_4d51_TabsBridgedEngine_reset_sync_id
++            10, // tabs:tabs_1c79_TabsBridgedEngine_reset_sync_id
+             FfiConverterTypeTabsBridgedEngine.lower(this),
+         )
+     }
+@@ -387,7 +387,7 @@
+     const functionCall = () => {
+         FfiConverterString.checkType("newSyncId", newSyncId);
+         return UniFFIScaffolding.callAsync(
+-            11, // tabs:tabs_4d51_TabsBridgedEngine_ensure_current_sync_id
++            11, // tabs:tabs_1c79_TabsBridgedEngine_ensure_current_sync_id
+             FfiConverterTypeTabsBridgedEngine.lower(this),
+             FfiConverterString.lower(newSyncId),
+         )
+@@ -403,7 +403,7 @@
+     const functionCall = () => {
+         FfiConverterString.checkType("clientData", clientData);
+         return UniFFIScaffolding.callAsync(
+-            12, // tabs:tabs_4d51_TabsBridgedEngine_prepare_for_sync
++            12, // tabs:tabs_1c79_TabsBridgedEngine_prepare_for_sync
+             FfiConverterTypeTabsBridgedEngine.lower(this),
+             FfiConverterString.lower(clientData),
+         )
+@@ -418,7 +418,7 @@
+     const liftError = (data) => FfiConverterTypeTabsError.lift(data);
+     const functionCall = () => {
+         return UniFFIScaffolding.callAsync(
+-            13, // tabs:tabs_4d51_TabsBridgedEngine_sync_started
++            13, // tabs:tabs_1c79_TabsBridgedEngine_sync_started
+             FfiConverterTypeTabsBridgedEngine.lower(this),
+         )
+     }
+@@ -433,7 +433,7 @@
+     const functionCall = () => {
+         FfiConverterSequencestring.checkType("incomingEnvelopesAsJson", incomingEnvelopesAsJson);
+         return UniFFIScaffolding.callAsync(
+-            14, // tabs:tabs_4d51_TabsBridgedEngine_store_incoming
++            14, // tabs:tabs_1c79_TabsBridgedEngine_store_incoming
+             FfiConverterTypeTabsBridgedEngine.lower(this),
+             FfiConverterSequencestring.lower(incomingEnvelopesAsJson),
+         )
+@@ -448,7 +448,7 @@
+     const liftError = (data) => FfiConverterTypeTabsError.lift(data);
+     const functionCall = () => {
+         return UniFFIScaffolding.callAsync(
+-            15, // tabs:tabs_4d51_TabsBridgedEngine_apply
++            15, // tabs:tabs_1c79_TabsBridgedEngine_apply
+             FfiConverterTypeTabsBridgedEngine.lower(this),
+         )
+     }
+@@ -464,7 +464,7 @@
+         FfiConverterI64.checkType("newTimestamp", newTimestamp);
+         FfiConverterSequenceTypeTabsGuid.checkType("uploadedIds", uploadedIds);
+         return UniFFIScaffolding.callAsync(
+-            16, // tabs:tabs_4d51_TabsBridgedEngine_set_uploaded
++            16, // tabs:tabs_1c79_TabsBridgedEngine_set_uploaded
+             FfiConverterTypeTabsBridgedEngine.lower(this),
+             FfiConverterI64.lower(newTimestamp),
+             FfiConverterSequenceTypeTabsGuid.lower(uploadedIds),
+@@ -480,7 +480,7 @@
+     const liftError = (data) => FfiConverterTypeTabsError.lift(data);
+     const functionCall = () => {
+         return UniFFIScaffolding.callAsync(
+-            17, // tabs:tabs_4d51_TabsBridgedEngine_sync_finished
++            17, // tabs:tabs_1c79_TabsBridgedEngine_sync_finished
+             FfiConverterTypeTabsBridgedEngine.lower(this),
+         )
+     }
+@@ -494,7 +494,7 @@
+     const liftError = (data) => FfiConverterTypeTabsError.lift(data);
+     const functionCall = () => {
+         return UniFFIScaffolding.callAsync(
+-            18, // tabs:tabs_4d51_TabsBridgedEngine_reset
++            18, // tabs:tabs_1c79_TabsBridgedEngine_reset
+             FfiConverterTypeTabsBridgedEngine.lower(this),
+         )
+     }
+@@ -508,7 +508,7 @@
+     const liftError = (data) => FfiConverterTypeTabsError.lift(data);
+     const functionCall = () => {
+         return UniFFIScaffolding.callAsync(
+-            19, // tabs:tabs_4d51_TabsBridgedEngine_wipe
++            19, // tabs:tabs_1c79_TabsBridgedEngine_wipe
+             FfiConverterTypeTabsBridgedEngine.lower(this),
+         )
+     }
+@@ -574,7 +574,7 @@
+     const functionCall = () => {
+         FfiConverterString.checkType("path", path);
+         return UniFFIScaffolding.callAsync(
+-            0, // tabs:tabs_4d51_TabsStore_new
++            0, // tabs:tabs_1c79_TabsStore_new
+             FfiConverterString.lower(path),
+         )
+     }
+@@ -588,7 +588,7 @@
+     const liftError = null;
+     const functionCall = () => {
+         return UniFFIScaffolding.callAsync(
+-            1, // tabs:tabs_4d51_TabsStore_get_all
++            1, // tabs:tabs_1c79_TabsStore_get_all
+             FfiConverterTypeTabsStore.lower(this),
+         )
+     }
+@@ -603,7 +603,7 @@
+     const functionCall = () => {
+         FfiConverterSequenceTypeRemoteTabRecord.checkType("remoteTabs", remoteTabs);
+         return UniFFIScaffolding.callAsync(
+-            2, // tabs:tabs_4d51_TabsStore_set_local_tabs
++            2, // tabs:tabs_1c79_TabsStore_set_local_tabs
+             FfiConverterTypeTabsStore.lower(this),
+             FfiConverterSequenceTypeRemoteTabRecord.lower(remoteTabs),
+         )
+@@ -618,7 +618,7 @@
+     const liftError = null;
+     const functionCall = () => {
+         return UniFFIScaffolding.callAsync(
+-            3, // tabs:tabs_4d51_TabsStore_register_with_sync_manager
++            3, // tabs:tabs_1c79_TabsStore_register_with_sync_manager
+             FfiConverterTypeTabsStore.lower(this),
+         )
+     }
+@@ -632,7 +632,7 @@
+     const liftError = (data) => FfiConverterTypeTabsError.lift(data);
+     const functionCall = () => {
+         return UniFFIScaffolding.callAsync(
+-            4, // tabs:tabs_4d51_TabsStore_reset
++            4, // tabs:tabs_1c79_TabsStore_reset
+             FfiConverterTypeTabsStore.lower(this),
+         )
+     }
+@@ -651,7 +651,7 @@
+         FfiConverterString.checkType("tokenserverUrl", tokenserverUrl);
+         FfiConverterString.checkType("localId", localId);
+         return UniFFIScaffolding.callAsync(
+-            5, // tabs:tabs_4d51_TabsStore_sync
++            5, // tabs:tabs_1c79_TabsStore_sync
+             FfiConverterTypeTabsStore.lower(this),
+             FfiConverterString.lower(keyId),
+             FfiConverterString.lower(accessToken),
+@@ -670,7 +670,7 @@
+     const liftError = null;
+     const functionCall = () => {
+         return UniFFIScaffolding.callAsync(
+-            6, // tabs:tabs_4d51_TabsStore_bridged_engine
++            6, // tabs:tabs_1c79_TabsStore_bridged_engine
+             FfiConverterTypeTabsStore.lower(this),
+         )
+     }
+diff -u -r --new-file firefox-108.0.orig/toolkit/components/uniffi-bindgen-gecko-js/fixtures/generated/RustArithmetic.jsm firefox-108.0/toolkit/components/uniffi-bindgen-gecko-js/fixtures/generated/RustArithmetic.jsm
+--- firefox-108.0.orig/toolkit/components/uniffi-bindgen-gecko-js/fixtures/generated/RustArithmetic.jsm	2022-12-08 10:27:29.000000000 -0600
++++ firefox-108.0/toolkit/components/uniffi-bindgen-gecko-js/fixtures/generated/RustArithmetic.jsm	2022-12-15 13:20:01.334880947 -0600
+@@ -338,7 +338,7 @@
+         FfiConverterU64.checkType("a", a);
+         FfiConverterU64.checkType("b", b);
+         return UniFFIScaffolding.callAsync(
+-            22, // arithmetic:arithmetic_906c_add
++            22, // arithmetic:arithmetic_be49_add
+             FfiConverterU64.lower(a),
+             FfiConverterU64.lower(b),
+         )
+@@ -359,7 +359,7 @@
+         FfiConverterU64.checkType("a", a);
+         FfiConverterU64.checkType("b", b);
+         return UniFFIScaffolding.callAsync(
+-            23, // arithmetic:arithmetic_906c_sub
++            23, // arithmetic:arithmetic_be49_sub
+             FfiConverterU64.lower(a),
+             FfiConverterU64.lower(b),
+         )
+@@ -380,7 +380,7 @@
+         FfiConverterU64.checkType("dividend", dividend);
+         FfiConverterU64.checkType("divisor", divisor);
+         return UniFFIScaffolding.callAsync(
+-            24, // arithmetic:arithmetic_906c_div
++            24, // arithmetic:arithmetic_be49_div
+             FfiConverterU64.lower(dividend),
+             FfiConverterU64.lower(divisor),
+         )
+@@ -401,7 +401,7 @@
+         FfiConverterU64.checkType("a", a);
+         FfiConverterU64.checkType("b", b);
+         return UniFFIScaffolding.callAsync(
+-            25, // arithmetic:arithmetic_906c_equal
++            25, // arithmetic:arithmetic_be49_equal
+             FfiConverterU64.lower(a),
+             FfiConverterU64.lower(b),
+         )
+diff -u -r --new-file firefox-108.0.orig/toolkit/components/uniffi-bindgen-gecko-js/fixtures/generated/RustCustomTypes.jsm firefox-108.0/toolkit/components/uniffi-bindgen-gecko-js/fixtures/generated/RustCustomTypes.jsm
+--- firefox-108.0.orig/toolkit/components/uniffi-bindgen-gecko-js/fixtures/generated/RustCustomTypes.jsm	2022-12-08 10:27:29.000000000 -0600
++++ firefox-108.0/toolkit/components/uniffi-bindgen-gecko-js/fixtures/generated/RustCustomTypes.jsm	2022-12-15 13:20:01.336880947 -0600
+@@ -422,7 +422,7 @@
+     const functionCall = () => {
+         FfiConverterOptionalTypeCustomTypesDemo.checkType("demo", demo);
+         return UniFFIScaffolding.callAsync(
+-            107, // custom_types:custom_types_8ecd_get_custom_types_demo
++            107, // custom_types:custom_types_41fc_get_custom_types_demo
+             FfiConverterOptionalTypeCustomTypesDemo.lower(demo),
+         )
+     }
+diff -u -r --new-file firefox-108.0.orig/toolkit/components/uniffi-bindgen-gecko-js/fixtures/generated/RustExternalTypes.jsm firefox-108.0/toolkit/components/uniffi-bindgen-gecko-js/fixtures/generated/RustExternalTypes.jsm
+--- firefox-108.0.orig/toolkit/components/uniffi-bindgen-gecko-js/fixtures/generated/RustExternalTypes.jsm	2022-12-08 10:27:28.000000000 -0600
++++ firefox-108.0/toolkit/components/uniffi-bindgen-gecko-js/fixtures/generated/RustExternalTypes.jsm	2022-12-15 13:20:01.336880947 -0600
+@@ -329,7 +329,7 @@
+     const functionCall = () => {
+         FfiConverterOptionalTypeLine.checkType("value", value);
+         return UniFFIScaffolding.callAsync(
+-            108, // external_types:external_types_54cc_gradient
++            108, // external_types:external_types_4cd4_gradient
+             FfiConverterOptionalTypeLine.lower(value),
+         )
+     }
+diff -u -r --new-file firefox-108.0.orig/toolkit/components/uniffi-bindgen-gecko-js/fixtures/generated/RustGeometry.jsm firefox-108.0/toolkit/components/uniffi-bindgen-gecko-js/fixtures/generated/RustGeometry.jsm
+--- firefox-108.0.orig/toolkit/components/uniffi-bindgen-gecko-js/fixtures/generated/RustGeometry.jsm	2022-12-08 10:27:29.000000000 -0600
++++ firefox-108.0/toolkit/components/uniffi-bindgen-gecko-js/fixtures/generated/RustGeometry.jsm	2022-12-15 13:20:01.334880947 -0600
+@@ -411,7 +411,7 @@
+     const functionCall = () => {
+         FfiConverterTypeLine.checkType("ln", ln);
+         return UniFFIScaffolding.callAsync(
+-            20, // geometry:geometry_1cce_gradient
++            20, // geometry:geometry_deb7_gradient
+             FfiConverterTypeLine.lower(ln),
+         )
+     }
+@@ -431,7 +431,7 @@
+         FfiConverterTypeLine.checkType("ln1", ln1);
+         FfiConverterTypeLine.checkType("ln2", ln2);
+         return UniFFIScaffolding.callAsync(
+-            21, // geometry:geometry_1cce_intersection
++            21, // geometry:geometry_deb7_intersection
+             FfiConverterTypeLine.lower(ln1),
+             FfiConverterTypeLine.lower(ln2),
+         )
+diff -u -r --new-file firefox-108.0.orig/toolkit/components/uniffi-bindgen-gecko-js/fixtures/generated/RustRondpoint.jsm firefox-108.0/toolkit/components/uniffi-bindgen-gecko-js/fixtures/generated/RustRondpoint.jsm
+--- firefox-108.0.orig/toolkit/components/uniffi-bindgen-gecko-js/fixtures/generated/RustRondpoint.jsm	2022-12-08 10:27:28.000000000 -0600
++++ firefox-108.0/toolkit/components/uniffi-bindgen-gecko-js/fixtures/generated/RustRondpoint.jsm	2022-12-15 13:20:01.335880947 -0600
+@@ -631,7 +631,7 @@
+     const liftError = null;
+     const functionCall = () => {
+         return UniFFIScaffolding.callAsync(
+-            55, // rondpoint:rondpoint_c6ef_Optionneur_new
++            55, // rondpoint:rondpoint_33e7_Optionneur_new
+         )
+     }
+     try {
+@@ -645,7 +645,7 @@
+     const functionCall = () => {
+         FfiConverterBool.checkType("value", value);
+         return UniFFIScaffolding.callAsync(
+-            56, // rondpoint:rondpoint_c6ef_Optionneur_sinon_boolean
++            56, // rondpoint:rondpoint_33e7_Optionneur_sinon_boolean
+             FfiConverterTypeOptionneur.lower(this),
+             FfiConverterBool.lower(value),
+         )
+@@ -661,7 +661,7 @@
+     const functionCall = () => {
+         FfiConverterString.checkType("value", value);
+         return UniFFIScaffolding.callAsync(
+-            57, // rondpoint:rondpoint_c6ef_Optionneur_sinon_string
++            57, // rondpoint:rondpoint_33e7_Optionneur_sinon_string
+             FfiConverterTypeOptionneur.lower(this),
+             FfiConverterString.lower(value),
+         )
+@@ -677,7 +677,7 @@
+     const functionCall = () => {
+         FfiConverterSequencestring.checkType("value", value);
+         return UniFFIScaffolding.callAsync(
+-            58, // rondpoint:rondpoint_c6ef_Optionneur_sinon_sequence
++            58, // rondpoint:rondpoint_33e7_Optionneur_sinon_sequence
+             FfiConverterTypeOptionneur.lower(this),
+             FfiConverterSequencestring.lower(value),
+         )
+@@ -693,7 +693,7 @@
+     const functionCall = () => {
+         FfiConverterOptionalstring.checkType("value", value);
+         return UniFFIScaffolding.callAsync(
+-            59, // rondpoint:rondpoint_c6ef_Optionneur_sinon_null
++            59, // rondpoint:rondpoint_33e7_Optionneur_sinon_null
+             FfiConverterTypeOptionneur.lower(this),
+             FfiConverterOptionalstring.lower(value),
+         )
+@@ -709,7 +709,7 @@
+     const functionCall = () => {
+         FfiConverterOptionali32.checkType("value", value);
+         return UniFFIScaffolding.callAsync(
+-            60, // rondpoint:rondpoint_c6ef_Optionneur_sinon_zero
++            60, // rondpoint:rondpoint_33e7_Optionneur_sinon_zero
+             FfiConverterTypeOptionneur.lower(this),
+             FfiConverterOptionali32.lower(value),
+         )
+@@ -725,7 +725,7 @@
+     const functionCall = () => {
+         FfiConverterU8.checkType("value", value);
+         return UniFFIScaffolding.callAsync(
+-            61, // rondpoint:rondpoint_c6ef_Optionneur_sinon_u8_dec
++            61, // rondpoint:rondpoint_33e7_Optionneur_sinon_u8_dec
+             FfiConverterTypeOptionneur.lower(this),
+             FfiConverterU8.lower(value),
+         )
+@@ -741,7 +741,7 @@
+     const functionCall = () => {
+         FfiConverterI8.checkType("value", value);
+         return UniFFIScaffolding.callAsync(
+-            62, // rondpoint:rondpoint_c6ef_Optionneur_sinon_i8_dec
++            62, // rondpoint:rondpoint_33e7_Optionneur_sinon_i8_dec
+             FfiConverterTypeOptionneur.lower(this),
+             FfiConverterI8.lower(value),
+         )
+@@ -757,7 +757,7 @@
+     const functionCall = () => {
+         FfiConverterU16.checkType("value", value);
+         return UniFFIScaffolding.callAsync(
+-            63, // rondpoint:rondpoint_c6ef_Optionneur_sinon_u16_dec
++            63, // rondpoint:rondpoint_33e7_Optionneur_sinon_u16_dec
+             FfiConverterTypeOptionneur.lower(this),
+             FfiConverterU16.lower(value),
+         )
+@@ -773,7 +773,7 @@
+     const functionCall = () => {
+         FfiConverterI16.checkType("value", value);
+         return UniFFIScaffolding.callAsync(
+-            64, // rondpoint:rondpoint_c6ef_Optionneur_sinon_i16_dec
++            64, // rondpoint:rondpoint_33e7_Optionneur_sinon_i16_dec
+             FfiConverterTypeOptionneur.lower(this),
+             FfiConverterI16.lower(value),
+         )
+@@ -789,7 +789,7 @@
+     const functionCall = () => {
+         FfiConverterU32.checkType("value", value);
+         return UniFFIScaffolding.callAsync(
+-            65, // rondpoint:rondpoint_c6ef_Optionneur_sinon_u32_dec
++            65, // rondpoint:rondpoint_33e7_Optionneur_sinon_u32_dec
+             FfiConverterTypeOptionneur.lower(this),
+             FfiConverterU32.lower(value),
+         )
+@@ -805,7 +805,7 @@
+     const functionCall = () => {
+         FfiConverterI32.checkType("value", value);
+         return UniFFIScaffolding.callAsync(
+-            66, // rondpoint:rondpoint_c6ef_Optionneur_sinon_i32_dec
++            66, // rondpoint:rondpoint_33e7_Optionneur_sinon_i32_dec
+             FfiConverterTypeOptionneur.lower(this),
+             FfiConverterI32.lower(value),
+         )
+@@ -821,7 +821,7 @@
+     const functionCall = () => {
+         FfiConverterU64.checkType("value", value);
+         return UniFFIScaffolding.callAsync(
+-            67, // rondpoint:rondpoint_c6ef_Optionneur_sinon_u64_dec
++            67, // rondpoint:rondpoint_33e7_Optionneur_sinon_u64_dec
+             FfiConverterTypeOptionneur.lower(this),
+             FfiConverterU64.lower(value),
+         )
+@@ -837,7 +837,7 @@
+     const functionCall = () => {
+         FfiConverterI64.checkType("value", value);
+         return UniFFIScaffolding.callAsync(
+-            68, // rondpoint:rondpoint_c6ef_Optionneur_sinon_i64_dec
++            68, // rondpoint:rondpoint_33e7_Optionneur_sinon_i64_dec
+             FfiConverterTypeOptionneur.lower(this),
+             FfiConverterI64.lower(value),
+         )
+@@ -853,7 +853,7 @@
+     const functionCall = () => {
+         FfiConverterU8.checkType("value", value);
+         return UniFFIScaffolding.callAsync(
+-            69, // rondpoint:rondpoint_c6ef_Optionneur_sinon_u8_hex
++            69, // rondpoint:rondpoint_33e7_Optionneur_sinon_u8_hex
+             FfiConverterTypeOptionneur.lower(this),
+             FfiConverterU8.lower(value),
+         )
+@@ -869,7 +869,7 @@
+     const functionCall = () => {
+         FfiConverterI8.checkType("value", value);
+         return UniFFIScaffolding.callAsync(
+-            70, // rondpoint:rondpoint_c6ef_Optionneur_sinon_i8_hex
++            70, // rondpoint:rondpoint_33e7_Optionneur_sinon_i8_hex
+             FfiConverterTypeOptionneur.lower(this),
+             FfiConverterI8.lower(value),
+         )
+@@ -885,7 +885,7 @@
+     const functionCall = () => {
+         FfiConverterU16.checkType("value", value);
+         return UniFFIScaffolding.callAsync(
+-            71, // rondpoint:rondpoint_c6ef_Optionneur_sinon_u16_hex
++            71, // rondpoint:rondpoint_33e7_Optionneur_sinon_u16_hex
+             FfiConverterTypeOptionneur.lower(this),
+             FfiConverterU16.lower(value),
+         )
+@@ -901,7 +901,7 @@
+     const functionCall = () => {
+         FfiConverterI16.checkType("value", value);
+         return UniFFIScaffolding.callAsync(
+-            72, // rondpoint:rondpoint_c6ef_Optionneur_sinon_i16_hex
++            72, // rondpoint:rondpoint_33e7_Optionneur_sinon_i16_hex
+             FfiConverterTypeOptionneur.lower(this),
+             FfiConverterI16.lower(value),
+         )
+@@ -917,7 +917,7 @@
+     const functionCall = () => {
+         FfiConverterU32.checkType("value", value);
+         return UniFFIScaffolding.callAsync(
+-            73, // rondpoint:rondpoint_c6ef_Optionneur_sinon_u32_hex
++            73, // rondpoint:rondpoint_33e7_Optionneur_sinon_u32_hex
+             FfiConverterTypeOptionneur.lower(this),
+             FfiConverterU32.lower(value),
+         )
+@@ -933,7 +933,7 @@
+     const functionCall = () => {
+         FfiConverterI32.checkType("value", value);
+         return UniFFIScaffolding.callAsync(
+-            74, // rondpoint:rondpoint_c6ef_Optionneur_sinon_i32_hex
++            74, // rondpoint:rondpoint_33e7_Optionneur_sinon_i32_hex
+             FfiConverterTypeOptionneur.lower(this),
+             FfiConverterI32.lower(value),
+         )
+@@ -949,7 +949,7 @@
+     const functionCall = () => {
+         FfiConverterU64.checkType("value", value);
+         return UniFFIScaffolding.callAsync(
+-            75, // rondpoint:rondpoint_c6ef_Optionneur_sinon_u64_hex
++            75, // rondpoint:rondpoint_33e7_Optionneur_sinon_u64_hex
+             FfiConverterTypeOptionneur.lower(this),
+             FfiConverterU64.lower(value),
+         )
+@@ -965,7 +965,7 @@
+     const functionCall = () => {
+         FfiConverterI64.checkType("value", value);
+         return UniFFIScaffolding.callAsync(
+-            76, // rondpoint:rondpoint_c6ef_Optionneur_sinon_i64_hex
++            76, // rondpoint:rondpoint_33e7_Optionneur_sinon_i64_hex
+             FfiConverterTypeOptionneur.lower(this),
+             FfiConverterI64.lower(value),
+         )
+@@ -981,7 +981,7 @@
+     const functionCall = () => {
+         FfiConverterU32.checkType("value", value);
+         return UniFFIScaffolding.callAsync(
+-            77, // rondpoint:rondpoint_c6ef_Optionneur_sinon_u32_oct
++            77, // rondpoint:rondpoint_33e7_Optionneur_sinon_u32_oct
+             FfiConverterTypeOptionneur.lower(this),
+             FfiConverterU32.lower(value),
+         )
+@@ -997,7 +997,7 @@
+     const functionCall = () => {
+         FfiConverterF32.checkType("value", value);
+         return UniFFIScaffolding.callAsync(
+-            78, // rondpoint:rondpoint_c6ef_Optionneur_sinon_f32
++            78, // rondpoint:rondpoint_33e7_Optionneur_sinon_f32
+             FfiConverterTypeOptionneur.lower(this),
+             FfiConverterF32.lower(value),
+         )
+@@ -1013,7 +1013,7 @@
+     const functionCall = () => {
+         FfiConverterF64.checkType("value", value);
+         return UniFFIScaffolding.callAsync(
+-            79, // rondpoint:rondpoint_c6ef_Optionneur_sinon_f64
++            79, // rondpoint:rondpoint_33e7_Optionneur_sinon_f64
+             FfiConverterTypeOptionneur.lower(this),
+             FfiConverterF64.lower(value),
+         )
+@@ -1029,7 +1029,7 @@
+     const functionCall = () => {
+         FfiConverterTypeEnumeration.checkType("value", value);
+         return UniFFIScaffolding.callAsync(
+-            80, // rondpoint:rondpoint_c6ef_Optionneur_sinon_enum
++            80, // rondpoint:rondpoint_33e7_Optionneur_sinon_enum
+             FfiConverterTypeOptionneur.lower(this),
+             FfiConverterTypeEnumeration.lower(value),
+         )
+@@ -1095,7 +1095,7 @@
+     const liftError = null;
+     const functionCall = () => {
+         return UniFFIScaffolding.callAsync(
+-            26, // rondpoint:rondpoint_c6ef_Retourneur_new
++            26, // rondpoint:rondpoint_33e7_Retourneur_new
+         )
+     }
+     try {
+@@ -1109,7 +1109,7 @@
+     const functionCall = () => {
+         FfiConverterI8.checkType("value", value);
+         return UniFFIScaffolding.callAsync(
+-            27, // rondpoint:rondpoint_c6ef_Retourneur_identique_i8
++            27, // rondpoint:rondpoint_33e7_Retourneur_identique_i8
+             FfiConverterTypeRetourneur.lower(this),
+             FfiConverterI8.lower(value),
+         )
+@@ -1125,7 +1125,7 @@
+     const functionCall = () => {
+         FfiConverterU8.checkType("value", value);
+         return UniFFIScaffolding.callAsync(
+-            28, // rondpoint:rondpoint_c6ef_Retourneur_identique_u8
++            28, // rondpoint:rondpoint_33e7_Retourneur_identique_u8
+             FfiConverterTypeRetourneur.lower(this),
+             FfiConverterU8.lower(value),
+         )
+@@ -1141,7 +1141,7 @@
+     const functionCall = () => {
+         FfiConverterI16.checkType("value", value);
+         return UniFFIScaffolding.callAsync(
+-            29, // rondpoint:rondpoint_c6ef_Retourneur_identique_i16
++            29, // rondpoint:rondpoint_33e7_Retourneur_identique_i16
+             FfiConverterTypeRetourneur.lower(this),
+             FfiConverterI16.lower(value),
+         )
+@@ -1157,7 +1157,7 @@
+     const functionCall = () => {
+         FfiConverterU16.checkType("value", value);
+         return UniFFIScaffolding.callAsync(
+-            30, // rondpoint:rondpoint_c6ef_Retourneur_identique_u16
++            30, // rondpoint:rondpoint_33e7_Retourneur_identique_u16
+             FfiConverterTypeRetourneur.lower(this),
+             FfiConverterU16.lower(value),
+         )
+@@ -1173,7 +1173,7 @@
+     const functionCall = () => {
+         FfiConverterI32.checkType("value", value);
+         return UniFFIScaffolding.callAsync(
+-            31, // rondpoint:rondpoint_c6ef_Retourneur_identique_i32
++            31, // rondpoint:rondpoint_33e7_Retourneur_identique_i32
+             FfiConverterTypeRetourneur.lower(this),
+             FfiConverterI32.lower(value),
+         )
+@@ -1189,7 +1189,7 @@
+     const functionCall = () => {
+         FfiConverterU32.checkType("value", value);
+         return UniFFIScaffolding.callAsync(
+-            32, // rondpoint:rondpoint_c6ef_Retourneur_identique_u32
++            32, // rondpoint:rondpoint_33e7_Retourneur_identique_u32
+             FfiConverterTypeRetourneur.lower(this),
+             FfiConverterU32.lower(value),
+         )
+@@ -1205,7 +1205,7 @@
+     const functionCall = () => {
+         FfiConverterI64.checkType("value", value);
+         return UniFFIScaffolding.callAsync(
+-            33, // rondpoint:rondpoint_c6ef_Retourneur_identique_i64
++            33, // rondpoint:rondpoint_33e7_Retourneur_identique_i64
+             FfiConverterTypeRetourneur.lower(this),
+             FfiConverterI64.lower(value),
+         )
+@@ -1221,7 +1221,7 @@
+     const functionCall = () => {
+         FfiConverterU64.checkType("value", value);
+         return UniFFIScaffolding.callAsync(
+-            34, // rondpoint:rondpoint_c6ef_Retourneur_identique_u64
++            34, // rondpoint:rondpoint_33e7_Retourneur_identique_u64
+             FfiConverterTypeRetourneur.lower(this),
+             FfiConverterU64.lower(value),
+         )
+@@ -1237,7 +1237,7 @@
+     const functionCall = () => {
+         FfiConverterF32.checkType("value", value);
+         return UniFFIScaffolding.callAsync(
+-            35, // rondpoint:rondpoint_c6ef_Retourneur_identique_float
++            35, // rondpoint:rondpoint_33e7_Retourneur_identique_float
+             FfiConverterTypeRetourneur.lower(this),
+             FfiConverterF32.lower(value),
+         )
+@@ -1253,7 +1253,7 @@
+     const functionCall = () => {
+         FfiConverterF64.checkType("value", value);
+         return UniFFIScaffolding.callAsync(
+-            36, // rondpoint:rondpoint_c6ef_Retourneur_identique_double
++            36, // rondpoint:rondpoint_33e7_Retourneur_identique_double
+             FfiConverterTypeRetourneur.lower(this),
+             FfiConverterF64.lower(value),
+         )
+@@ -1269,7 +1269,7 @@
+     const functionCall = () => {
+         FfiConverterBool.checkType("value", value);
+         return UniFFIScaffolding.callAsync(
+-            37, // rondpoint:rondpoint_c6ef_Retourneur_identique_boolean
++            37, // rondpoint:rondpoint_33e7_Retourneur_identique_boolean
+             FfiConverterTypeRetourneur.lower(this),
+             FfiConverterBool.lower(value),
+         )
+@@ -1285,7 +1285,7 @@
+     const functionCall = () => {
+         FfiConverterString.checkType("value", value);
+         return UniFFIScaffolding.callAsync(
+-            38, // rondpoint:rondpoint_c6ef_Retourneur_identique_string
++            38, // rondpoint:rondpoint_33e7_Retourneur_identique_string
+             FfiConverterTypeRetourneur.lower(this),
+             FfiConverterString.lower(value),
+         )
+@@ -1301,7 +1301,7 @@
+     const functionCall = () => {
+         FfiConverterTypeDictionnaireNombresSignes.checkType("value", value);
+         return UniFFIScaffolding.callAsync(
+-            39, // rondpoint:rondpoint_c6ef_Retourneur_identique_nombres_signes
++            39, // rondpoint:rondpoint_33e7_Retourneur_identique_nombres_signes
+             FfiConverterTypeRetourneur.lower(this),
+             FfiConverterTypeDictionnaireNombresSignes.lower(value),
+         )
+@@ -1317,7 +1317,7 @@
+     const functionCall = () => {
+         FfiConverterTypeDictionnaireNombres.checkType("value", value);
+         return UniFFIScaffolding.callAsync(
+-            40, // rondpoint:rondpoint_c6ef_Retourneur_identique_nombres
++            40, // rondpoint:rondpoint_33e7_Retourneur_identique_nombres
+             FfiConverterTypeRetourneur.lower(this),
+             FfiConverterTypeDictionnaireNombres.lower(value),
+         )
+@@ -1333,7 +1333,7 @@
+     const functionCall = () => {
+         FfiConverterTypeOptionneurDictionnaire.checkType("value", value);
+         return UniFFIScaffolding.callAsync(
+-            41, // rondpoint:rondpoint_c6ef_Retourneur_identique_optionneur_dictionnaire
++            41, // rondpoint:rondpoint_33e7_Retourneur_identique_optionneur_dictionnaire
+             FfiConverterTypeRetourneur.lower(this),
+             FfiConverterTypeOptionneurDictionnaire.lower(value),
+         )
+@@ -1399,7 +1399,7 @@
+     const liftError = null;
+     const functionCall = () => {
+         return UniFFIScaffolding.callAsync(
+-            42, // rondpoint:rondpoint_c6ef_Stringifier_new
++            42, // rondpoint:rondpoint_33e7_Stringifier_new
+         )
+     }
+     try {
+@@ -1413,7 +1413,7 @@
+     const functionCall = () => {
+         FfiConverterString.checkType("value", value);
+         return UniFFIScaffolding.callAsync(
+-            43, // rondpoint:rondpoint_c6ef_Stringifier_well_known_string
++            43, // rondpoint:rondpoint_33e7_Stringifier_well_known_string
+             FfiConverterTypeStringifier.lower(this),
+             FfiConverterString.lower(value),
+         )
+@@ -1429,7 +1429,7 @@
+     const functionCall = () => {
+         FfiConverterI8.checkType("value", value);
+         return UniFFIScaffolding.callAsync(
+-            44, // rondpoint:rondpoint_c6ef_Stringifier_to_string_i8
++            44, // rondpoint:rondpoint_33e7_Stringifier_to_string_i8
+             FfiConverterTypeStringifier.lower(this),
+             FfiConverterI8.lower(value),
+         )
+@@ -1445,7 +1445,7 @@
+     const functionCall = () => {
+         FfiConverterU8.checkType("value", value);
+         return UniFFIScaffolding.callAsync(
+-            45, // rondpoint:rondpoint_c6ef_Stringifier_to_string_u8
++            45, // rondpoint:rondpoint_33e7_Stringifier_to_string_u8
+             FfiConverterTypeStringifier.lower(this),
+             FfiConverterU8.lower(value),
+         )
+@@ -1461,7 +1461,7 @@
+     const functionCall = () => {
+         FfiConverterI16.checkType("value", value);
+         return UniFFIScaffolding.callAsync(
+-            46, // rondpoint:rondpoint_c6ef_Stringifier_to_string_i16
++            46, // rondpoint:rondpoint_33e7_Stringifier_to_string_i16
+             FfiConverterTypeStringifier.lower(this),
+             FfiConverterI16.lower(value),
+         )
+@@ -1477,7 +1477,7 @@
+     const functionCall = () => {
+         FfiConverterU16.checkType("value", value);
+         return UniFFIScaffolding.callAsync(
+-            47, // rondpoint:rondpoint_c6ef_Stringifier_to_string_u16
++            47, // rondpoint:rondpoint_33e7_Stringifier_to_string_u16
+             FfiConverterTypeStringifier.lower(this),
+             FfiConverterU16.lower(value),
+         )
+@@ -1493,7 +1493,7 @@
+     const functionCall = () => {
+         FfiConverterI32.checkType("value", value);
+         return UniFFIScaffolding.callAsync(
+-            48, // rondpoint:rondpoint_c6ef_Stringifier_to_string_i32
++            48, // rondpoint:rondpoint_33e7_Stringifier_to_string_i32
+             FfiConverterTypeStringifier.lower(this),
+             FfiConverterI32.lower(value),
+         )
+@@ -1509,7 +1509,7 @@
+     const functionCall = () => {
+         FfiConverterU32.checkType("value", value);
+         return UniFFIScaffolding.callAsync(
+-            49, // rondpoint:rondpoint_c6ef_Stringifier_to_string_u32
++            49, // rondpoint:rondpoint_33e7_Stringifier_to_string_u32
+             FfiConverterTypeStringifier.lower(this),
+             FfiConverterU32.lower(value),
+         )
+@@ -1525,7 +1525,7 @@
+     const functionCall = () => {
+         FfiConverterI64.checkType("value", value);
+         return UniFFIScaffolding.callAsync(
+-            50, // rondpoint:rondpoint_c6ef_Stringifier_to_string_i64
++            50, // rondpoint:rondpoint_33e7_Stringifier_to_string_i64
+             FfiConverterTypeStringifier.lower(this),
+             FfiConverterI64.lower(value),
+         )
+@@ -1541,7 +1541,7 @@
+     const functionCall = () => {
+         FfiConverterU64.checkType("value", value);
+         return UniFFIScaffolding.callAsync(
+-            51, // rondpoint:rondpoint_c6ef_Stringifier_to_string_u64
++            51, // rondpoint:rondpoint_33e7_Stringifier_to_string_u64
+             FfiConverterTypeStringifier.lower(this),
+             FfiConverterU64.lower(value),
+         )
+@@ -1557,7 +1557,7 @@
+     const functionCall = () => {
+         FfiConverterF32.checkType("value", value);
+         return UniFFIScaffolding.callAsync(
+-            52, // rondpoint:rondpoint_c6ef_Stringifier_to_string_float
++            52, // rondpoint:rondpoint_33e7_Stringifier_to_string_float
+             FfiConverterTypeStringifier.lower(this),
+             FfiConverterF32.lower(value),
+         )
+@@ -1573,7 +1573,7 @@
+     const functionCall = () => {
+         FfiConverterF64.checkType("value", value);
+         return UniFFIScaffolding.callAsync(
+-            53, // rondpoint:rondpoint_c6ef_Stringifier_to_string_double
++            53, // rondpoint:rondpoint_33e7_Stringifier_to_string_double
+             FfiConverterTypeStringifier.lower(this),
+             FfiConverterF64.lower(value),
+         )
+@@ -1589,7 +1589,7 @@
+     const functionCall = () => {
+         FfiConverterBool.checkType("value", value);
+         return UniFFIScaffolding.callAsync(
+-            54, // rondpoint:rondpoint_c6ef_Stringifier_to_string_boolean
++            54, // rondpoint:rondpoint_33e7_Stringifier_to_string_boolean
+             FfiConverterTypeStringifier.lower(this),
+             FfiConverterBool.lower(value),
+         )
+@@ -2375,7 +2375,7 @@
+     const functionCall = () => {
+         FfiConverterTypeDictionnaire.checkType("d", d);
+         return UniFFIScaffolding.callAsync(
+-            81, // rondpoint:rondpoint_c6ef_copie_dictionnaire
++            81, // rondpoint:rondpoint_33e7_copie_dictionnaire
+             FfiConverterTypeDictionnaire.lower(d),
+         )
+     }
+@@ -2394,7 +2394,7 @@
+     const functionCall = () => {
+         FfiConverterTypeEnumeration.checkType("e", e);
+         return UniFFIScaffolding.callAsync(
+-            82, // rondpoint:rondpoint_c6ef_copie_enumeration
++            82, // rondpoint:rondpoint_33e7_copie_enumeration
+             FfiConverterTypeEnumeration.lower(e),
+         )
+     }
+@@ -2413,7 +2413,7 @@
+     const functionCall = () => {
+         FfiConverterSequenceTypeEnumeration.checkType("e", e);
+         return UniFFIScaffolding.callAsync(
+-            83, // rondpoint:rondpoint_c6ef_copie_enumerations
++            83, // rondpoint:rondpoint_33e7_copie_enumerations
+             FfiConverterSequenceTypeEnumeration.lower(e),
+         )
+     }
+@@ -2432,7 +2432,7 @@
+     const functionCall = () => {
+         FfiConverterMapStringTypeEnumerationAvecDonnees.checkType("c", c);
+         return UniFFIScaffolding.callAsync(
+-            84, // rondpoint:rondpoint_c6ef_copie_carte
++            84, // rondpoint:rondpoint_33e7_copie_carte
+             FfiConverterMapStringTypeEnumerationAvecDonnees.lower(c),
+         )
+     }
+@@ -2451,7 +2451,7 @@
+     const functionCall = () => {
+         FfiConverterBool.checkType("b", b);
+         return UniFFIScaffolding.callAsync(
+-            85, // rondpoint:rondpoint_c6ef_switcheroo
++            85, // rondpoint:rondpoint_33e7_switcheroo
+             FfiConverterBool.lower(b),
+         )
+     }
+diff -u -r --new-file firefox-108.0.orig/toolkit/components/uniffi-bindgen-gecko-js/fixtures/generated/RustSprites.jsm firefox-108.0/toolkit/components/uniffi-bindgen-gecko-js/fixtures/generated/RustSprites.jsm
+--- firefox-108.0.orig/toolkit/components/uniffi-bindgen-gecko-js/fixtures/generated/RustSprites.jsm	2022-12-08 10:27:29.000000000 -0600
++++ firefox-108.0/toolkit/components/uniffi-bindgen-gecko-js/fixtures/generated/RustSprites.jsm	2022-12-15 13:20:01.335880947 -0600
+@@ -309,7 +309,7 @@
+     const functionCall = () => {
+         FfiConverterOptionalTypePoint.checkType("initialPosition", initialPosition);
+         return UniFFIScaffolding.callAsync(
+-            86, // sprites:sprites_accb_Sprite_new
++            86, // sprites:sprites_a679_Sprite_new
+             FfiConverterOptionalTypePoint.lower(initialPosition),
+         )
+     }
+@@ -331,7 +331,7 @@
+         FfiConverterTypePoint.checkType("reference", reference);
+         FfiConverterTypeVector.checkType("direction", direction);
+         return UniFFIScaffolding.callAsync(
+-            87, // sprites:sprites_accb_Sprite_new_relative_to
++            87, // sprites:sprites_a679_Sprite_new_relative_to
+             FfiConverterTypePoint.lower(reference),
+             FfiConverterTypeVector.lower(direction),
+         )
+@@ -346,7 +346,7 @@
+     const liftError = null;
+     const functionCall = () => {
+         return UniFFIScaffolding.callAsync(
+-            88, // sprites:sprites_accb_Sprite_get_position
++            88, // sprites:sprites_a679_Sprite_get_position
+             FfiConverterTypeSprite.lower(this),
+         )
+     }
+@@ -361,7 +361,7 @@
+     const functionCall = () => {
+         FfiConverterTypePoint.checkType("position", position);
+         return UniFFIScaffolding.callAsync(
+-            89, // sprites:sprites_accb_Sprite_move_to
++            89, // sprites:sprites_a679_Sprite_move_to
+             FfiConverterTypeSprite.lower(this),
+             FfiConverterTypePoint.lower(position),
+         )
+@@ -377,7 +377,7 @@
+     const functionCall = () => {
+         FfiConverterTypeVector.checkType("direction", direction);
+         return UniFFIScaffolding.callAsync(
+-            90, // sprites:sprites_accb_Sprite_move_by
++            90, // sprites:sprites_a679_Sprite_move_by
+             FfiConverterTypeSprite.lower(this),
+             FfiConverterTypeVector.lower(direction),
+         )
+@@ -567,7 +567,7 @@
+         FfiConverterTypePoint.checkType("position", position);
+         FfiConverterTypeVector.checkType("direction", direction);
+         return UniFFIScaffolding.callAsync(
+-            91, // sprites:sprites_accb_translate
++            91, // sprites:sprites_a679_translate
+             FfiConverterTypePoint.lower(position),
+             FfiConverterTypeVector.lower(direction),
+         )
+diff -u -r --new-file firefox-108.0.orig/toolkit/components/uniffi-bindgen-gecko-js/fixtures/generated/RustTodolist.jsm firefox-108.0/toolkit/components/uniffi-bindgen-gecko-js/fixtures/generated/RustTodolist.jsm
+--- firefox-108.0.orig/toolkit/components/uniffi-bindgen-gecko-js/fixtures/generated/RustTodolist.jsm	2022-12-08 10:27:29.000000000 -0600
++++ firefox-108.0/toolkit/components/uniffi-bindgen-gecko-js/fixtures/generated/RustTodolist.jsm	2022-12-15 13:20:01.336880947 -0600
+@@ -287,7 +287,7 @@
+     const liftError = null;
+     const functionCall = () => {
+         return UniFFIScaffolding.callAsync(
+-            92, // todolist:todolist_aa33_TodoList_new
++            92, // todolist:todolist_cd5b_TodoList_new
+         )
+     }
+     try {
+@@ -301,7 +301,7 @@
+     const functionCall = () => {
+         FfiConverterString.checkType("todo", todo);
+         return UniFFIScaffolding.callAsync(
+-            93, // todolist:todolist_aa33_TodoList_add_item
++            93, // todolist:todolist_cd5b_TodoList_add_item
+             FfiConverterTypeTodoList.lower(this),
+             FfiConverterString.lower(todo),
+         )
+@@ -317,7 +317,7 @@
+     const functionCall = () => {
+         FfiConverterTypeTodoEntry.checkType("entry", entry);
+         return UniFFIScaffolding.callAsync(
+-            94, // todolist:todolist_aa33_TodoList_add_entry
++            94, // todolist:todolist_cd5b_TodoList_add_entry
+             FfiConverterTypeTodoList.lower(this),
+             FfiConverterTypeTodoEntry.lower(entry),
+         )
+@@ -332,7 +332,7 @@
+     const liftError = null;
+     const functionCall = () => {
+         return UniFFIScaffolding.callAsync(
+-            95, // todolist:todolist_aa33_TodoList_get_entries
++            95, // todolist:todolist_cd5b_TodoList_get_entries
+             FfiConverterTypeTodoList.lower(this),
+         )
+     }
+@@ -346,7 +346,7 @@
+     const liftError = null;
+     const functionCall = () => {
+         return UniFFIScaffolding.callAsync(
+-            96, // todolist:todolist_aa33_TodoList_get_items
++            96, // todolist:todolist_cd5b_TodoList_get_items
+             FfiConverterTypeTodoList.lower(this),
+         )
+     }
+@@ -361,7 +361,7 @@
+     const functionCall = () => {
+         FfiConverterSequenceTypeTodoEntry.checkType("entries", entries);
+         return UniFFIScaffolding.callAsync(
+-            97, // todolist:todolist_aa33_TodoList_add_entries
++            97, // todolist:todolist_cd5b_TodoList_add_entries
+             FfiConverterTypeTodoList.lower(this),
+             FfiConverterSequenceTypeTodoEntry.lower(entries),
+         )
+@@ -377,7 +377,7 @@
+     const functionCall = () => {
+         FfiConverterSequencestring.checkType("items", items);
+         return UniFFIScaffolding.callAsync(
+-            98, // todolist:todolist_aa33_TodoList_add_items
++            98, // todolist:todolist_cd5b_TodoList_add_items
+             FfiConverterTypeTodoList.lower(this),
+             FfiConverterSequencestring.lower(items),
+         )
+@@ -392,7 +392,7 @@
+     const liftError = (data) => FfiConverterTypeTodoError.lift(data);
+     const functionCall = () => {
+         return UniFFIScaffolding.callAsync(
+-            99, // todolist:todolist_aa33_TodoList_get_last_entry
++            99, // todolist:todolist_cd5b_TodoList_get_last_entry
+             FfiConverterTypeTodoList.lower(this),
+         )
+     }
+@@ -406,7 +406,7 @@
+     const liftError = (data) => FfiConverterTypeTodoError.lift(data);
+     const functionCall = () => {
+         return UniFFIScaffolding.callAsync(
+-            100, // todolist:todolist_aa33_TodoList_get_last
++            100, // todolist:todolist_cd5b_TodoList_get_last
+             FfiConverterTypeTodoList.lower(this),
+         )
+     }
+@@ -420,7 +420,7 @@
+     const liftError = (data) => FfiConverterTypeTodoError.lift(data);
+     const functionCall = () => {
+         return UniFFIScaffolding.callAsync(
+-            101, // todolist:todolist_aa33_TodoList_get_first
++            101, // todolist:todolist_cd5b_TodoList_get_first
+             FfiConverterTypeTodoList.lower(this),
+         )
+     }
+@@ -435,7 +435,7 @@
+     const functionCall = () => {
+         FfiConverterString.checkType("todo", todo);
+         return UniFFIScaffolding.callAsync(
+-            102, // todolist:todolist_aa33_TodoList_clear_item
++            102, // todolist:todolist_cd5b_TodoList_clear_item
+             FfiConverterTypeTodoList.lower(this),
+             FfiConverterString.lower(todo),
+         )
+@@ -450,7 +450,7 @@
+     const liftError = null;
+     const functionCall = () => {
+         return UniFFIScaffolding.callAsync(
+-            103, // todolist:todolist_aa33_TodoList_make_default
++            103, // todolist:todolist_cd5b_TodoList_make_default
+             FfiConverterTypeTodoList.lower(this),
+         )
+     }
+@@ -711,7 +711,7 @@
+     const liftError = null;
+     const functionCall = () => {
+         return UniFFIScaffolding.callAsync(
+-            104, // todolist:todolist_aa33_get_default_list
++            104, // todolist:todolist_cd5b_get_default_list
+         )
+     }
+     try {
+@@ -729,7 +729,7 @@
+     const functionCall = () => {
+         FfiConverterTypeTodoList.checkType("list", list);
+         return UniFFIScaffolding.callAsync(
+-            105, // todolist:todolist_aa33_set_default_list
++            105, // todolist:todolist_cd5b_set_default_list
+             FfiConverterTypeTodoList.lower(list),
+         )
+     }
+@@ -748,7 +748,7 @@
+     const functionCall = () => {
+         FfiConverterString.checkType("todo", todo);
+         return UniFFIScaffolding.callAsync(
+-            106, // todolist:todolist_aa33_create_entry_with
++            106, // todolist:todolist_cd5b_create_entry_with
+             FfiConverterString.lower(todo),
+         )
+     }
+diff -u -r --new-file firefox-108.0.orig/toolkit/components/uniffi-js/UniFFIFixtureScaffolding.cpp firefox-108.0/toolkit/components/uniffi-js/UniFFIFixtureScaffolding.cpp
+--- firefox-108.0.orig/toolkit/components/uniffi-js/UniFFIFixtureScaffolding.cpp	2022-12-08 10:27:29.000000000 -0600
++++ firefox-108.0/toolkit/components/uniffi-js/UniFFIFixtureScaffolding.cpp	2022-12-15 13:20:01.332880947 -0600
+@@ -19,481 +19,481 @@
+ 
+ // Define scaffolding functions from UniFFI
+ extern "C" {
+-  double geometry_1cce_gradient(RustBuffer, RustCallStatus*);
+-  RustBuffer geometry_1cce_intersection(RustBuffer, RustBuffer, RustCallStatus*);
+-  uint64_t arithmetic_906c_add(uint64_t, uint64_t, RustCallStatus*);
+-  uint64_t arithmetic_906c_sub(uint64_t, uint64_t, RustCallStatus*);
+-  uint64_t arithmetic_906c_div(uint64_t, uint64_t, RustCallStatus*);
+-  int8_t arithmetic_906c_equal(uint64_t, uint64_t, RustCallStatus*);
+-  void ffi_rondpoint_c6ef_Retourneur_object_free(void *, RustCallStatus*);
+-  void * rondpoint_c6ef_Retourneur_new(RustCallStatus*);
+-  int8_t rondpoint_c6ef_Retourneur_identique_i8(void *, int8_t, RustCallStatus*);
+-  uint8_t rondpoint_c6ef_Retourneur_identique_u8(void *, uint8_t, RustCallStatus*);
+-  int16_t rondpoint_c6ef_Retourneur_identique_i16(void *, int16_t, RustCallStatus*);
+-  uint16_t rondpoint_c6ef_Retourneur_identique_u16(void *, uint16_t, RustCallStatus*);
+-  int32_t rondpoint_c6ef_Retourneur_identique_i32(void *, int32_t, RustCallStatus*);
+-  uint32_t rondpoint_c6ef_Retourneur_identique_u32(void *, uint32_t, RustCallStatus*);
+-  int64_t rondpoint_c6ef_Retourneur_identique_i64(void *, int64_t, RustCallStatus*);
+-  uint64_t rondpoint_c6ef_Retourneur_identique_u64(void *, uint64_t, RustCallStatus*);
+-  float rondpoint_c6ef_Retourneur_identique_float(void *, float, RustCallStatus*);
+-  double rondpoint_c6ef_Retourneur_identique_double(void *, double, RustCallStatus*);
+-  int8_t rondpoint_c6ef_Retourneur_identique_boolean(void *, int8_t, RustCallStatus*);
+-  RustBuffer rondpoint_c6ef_Retourneur_identique_string(void *, RustBuffer, RustCallStatus*);
+-  RustBuffer rondpoint_c6ef_Retourneur_identique_nombres_signes(void *, RustBuffer, RustCallStatus*);
+-  RustBuffer rondpoint_c6ef_Retourneur_identique_nombres(void *, RustBuffer, RustCallStatus*);
+-  RustBuffer rondpoint_c6ef_Retourneur_identique_optionneur_dictionnaire(void *, RustBuffer, RustCallStatus*);
+-  void ffi_rondpoint_c6ef_Stringifier_object_free(void *, RustCallStatus*);
+-  void * rondpoint_c6ef_Stringifier_new(RustCallStatus*);
+-  RustBuffer rondpoint_c6ef_Stringifier_well_known_string(void *, RustBuffer, RustCallStatus*);
+-  RustBuffer rondpoint_c6ef_Stringifier_to_string_i8(void *, int8_t, RustCallStatus*);
+-  RustBuffer rondpoint_c6ef_Stringifier_to_string_u8(void *, uint8_t, RustCallStatus*);
+-  RustBuffer rondpoint_c6ef_Stringifier_to_string_i16(void *, int16_t, RustCallStatus*);
+-  RustBuffer rondpoint_c6ef_Stringifier_to_string_u16(void *, uint16_t, RustCallStatus*);
+-  RustBuffer rondpoint_c6ef_Stringifier_to_string_i32(void *, int32_t, RustCallStatus*);
+-  RustBuffer rondpoint_c6ef_Stringifier_to_string_u32(void *, uint32_t, RustCallStatus*);
+-  RustBuffer rondpoint_c6ef_Stringifier_to_string_i64(void *, int64_t, RustCallStatus*);
+-  RustBuffer rondpoint_c6ef_Stringifier_to_string_u64(void *, uint64_t, RustCallStatus*);
+-  RustBuffer rondpoint_c6ef_Stringifier_to_string_float(void *, float, RustCallStatus*);
+-  RustBuffer rondpoint_c6ef_Stringifier_to_string_double(void *, double, RustCallStatus*);
+-  RustBuffer rondpoint_c6ef_Stringifier_to_string_boolean(void *, int8_t, RustCallStatus*);
+-  void ffi_rondpoint_c6ef_Optionneur_object_free(void *, RustCallStatus*);
+-  void * rondpoint_c6ef_Optionneur_new(RustCallStatus*);
+-  int8_t rondpoint_c6ef_Optionneur_sinon_boolean(void *, int8_t, RustCallStatus*);
+-  RustBuffer rondpoint_c6ef_Optionneur_sinon_string(void *, RustBuffer, RustCallStatus*);
+-  RustBuffer rondpoint_c6ef_Optionneur_sinon_sequence(void *, RustBuffer, RustCallStatus*);
+-  RustBuffer rondpoint_c6ef_Optionneur_sinon_null(void *, RustBuffer, RustCallStatus*);
+-  RustBuffer rondpoint_c6ef_Optionneur_sinon_zero(void *, RustBuffer, RustCallStatus*);
+-  uint8_t rondpoint_c6ef_Optionneur_sinon_u8_dec(void *, uint8_t, RustCallStatus*);
+-  int8_t rondpoint_c6ef_Optionneur_sinon_i8_dec(void *, int8_t, RustCallStatus*);
+-  uint16_t rondpoint_c6ef_Optionneur_sinon_u16_dec(void *, uint16_t, RustCallStatus*);
+-  int16_t rondpoint_c6ef_Optionneur_sinon_i16_dec(void *, int16_t, RustCallStatus*);
+-  uint32_t rondpoint_c6ef_Optionneur_sinon_u32_dec(void *, uint32_t, RustCallStatus*);
+-  int32_t rondpoint_c6ef_Optionneur_sinon_i32_dec(void *, int32_t, RustCallStatus*);
+-  uint64_t rondpoint_c6ef_Optionneur_sinon_u64_dec(void *, uint64_t, RustCallStatus*);
+-  int64_t rondpoint_c6ef_Optionneur_sinon_i64_dec(void *, int64_t, RustCallStatus*);
+-  uint8_t rondpoint_c6ef_Optionneur_sinon_u8_hex(void *, uint8_t, RustCallStatus*);
+-  int8_t rondpoint_c6ef_Optionneur_sinon_i8_hex(void *, int8_t, RustCallStatus*);
+-  uint16_t rondpoint_c6ef_Optionneur_sinon_u16_hex(void *, uint16_t, RustCallStatus*);
+-  int16_t rondpoint_c6ef_Optionneur_sinon_i16_hex(void *, int16_t, RustCallStatus*);
+-  uint32_t rondpoint_c6ef_Optionneur_sinon_u32_hex(void *, uint32_t, RustCallStatus*);
+-  int32_t rondpoint_c6ef_Optionneur_sinon_i32_hex(void *, int32_t, RustCallStatus*);
+-  uint64_t rondpoint_c6ef_Optionneur_sinon_u64_hex(void *, uint64_t, RustCallStatus*);
+-  int64_t rondpoint_c6ef_Optionneur_sinon_i64_hex(void *, int64_t, RustCallStatus*);
+-  uint32_t rondpoint_c6ef_Optionneur_sinon_u32_oct(void *, uint32_t, RustCallStatus*);
+-  float rondpoint_c6ef_Optionneur_sinon_f32(void *, float, RustCallStatus*);
+-  double rondpoint_c6ef_Optionneur_sinon_f64(void *, double, RustCallStatus*);
+-  RustBuffer rondpoint_c6ef_Optionneur_sinon_enum(void *, RustBuffer, RustCallStatus*);
+-  RustBuffer rondpoint_c6ef_copie_dictionnaire(RustBuffer, RustCallStatus*);
+-  RustBuffer rondpoint_c6ef_copie_enumeration(RustBuffer, RustCallStatus*);
+-  RustBuffer rondpoint_c6ef_copie_enumerations(RustBuffer, RustCallStatus*);
+-  RustBuffer rondpoint_c6ef_copie_carte(RustBuffer, RustCallStatus*);
+-  int8_t rondpoint_c6ef_switcheroo(int8_t, RustCallStatus*);
+-  void ffi_sprites_accb_Sprite_object_free(void *, RustCallStatus*);
+-  void * sprites_accb_Sprite_new(RustBuffer, RustCallStatus*);
+-  void * sprites_accb_Sprite_new_relative_to(RustBuffer, RustBuffer, RustCallStatus*);
+-  RustBuffer sprites_accb_Sprite_get_position(void *, RustCallStatus*);
+-  void sprites_accb_Sprite_move_to(void *, RustBuffer, RustCallStatus*);
+-  void sprites_accb_Sprite_move_by(void *, RustBuffer, RustCallStatus*);
+-  RustBuffer sprites_accb_translate(RustBuffer, RustBuffer, RustCallStatus*);
+-  void ffi_todolist_aa33_TodoList_object_free(void *, RustCallStatus*);
+-  void * todolist_aa33_TodoList_new(RustCallStatus*);
+-  void todolist_aa33_TodoList_add_item(void *, RustBuffer, RustCallStatus*);
+-  void todolist_aa33_TodoList_add_entry(void *, RustBuffer, RustCallStatus*);
+-  RustBuffer todolist_aa33_TodoList_get_entries(void *, RustCallStatus*);
+-  RustBuffer todolist_aa33_TodoList_get_items(void *, RustCallStatus*);
+-  void todolist_aa33_TodoList_add_entries(void *, RustBuffer, RustCallStatus*);
+-  void todolist_aa33_TodoList_add_items(void *, RustBuffer, RustCallStatus*);
+-  RustBuffer todolist_aa33_TodoList_get_last_entry(void *, RustCallStatus*);
+-  RustBuffer todolist_aa33_TodoList_get_last(void *, RustCallStatus*);
+-  RustBuffer todolist_aa33_TodoList_get_first(void *, RustCallStatus*);
+-  void todolist_aa33_TodoList_clear_item(void *, RustBuffer, RustCallStatus*);
+-  void todolist_aa33_TodoList_make_default(void *, RustCallStatus*);
+-  RustBuffer todolist_aa33_get_default_list(RustCallStatus*);
+-  void todolist_aa33_set_default_list(void *, RustCallStatus*);
+-  RustBuffer todolist_aa33_create_entry_with(RustBuffer, RustCallStatus*);
+-  RustBuffer custom_types_8ecd_get_custom_types_demo(RustBuffer, RustCallStatus*);
+-  double external_types_54cc_gradient(RustBuffer, RustCallStatus*);
++  double geometry_deb7_gradient(RustBuffer, RustCallStatus*);
++  RustBuffer geometry_deb7_intersection(RustBuffer, RustBuffer, RustCallStatus*);
++  uint64_t arithmetic_be49_add(uint64_t, uint64_t, RustCallStatus*);
++  uint64_t arithmetic_be49_sub(uint64_t, uint64_t, RustCallStatus*);
++  uint64_t arithmetic_be49_div(uint64_t, uint64_t, RustCallStatus*);
++  int8_t arithmetic_be49_equal(uint64_t, uint64_t, RustCallStatus*);
++  void ffi_rondpoint_33e7_Retourneur_object_free(void *, RustCallStatus*);
++  void * rondpoint_33e7_Retourneur_new(RustCallStatus*);
++  int8_t rondpoint_33e7_Retourneur_identique_i8(void *, int8_t, RustCallStatus*);
++  uint8_t rondpoint_33e7_Retourneur_identique_u8(void *, uint8_t, RustCallStatus*);
++  int16_t rondpoint_33e7_Retourneur_identique_i16(void *, int16_t, RustCallStatus*);
++  uint16_t rondpoint_33e7_Retourneur_identique_u16(void *, uint16_t, RustCallStatus*);
++  int32_t rondpoint_33e7_Retourneur_identique_i32(void *, int32_t, RustCallStatus*);
++  uint32_t rondpoint_33e7_Retourneur_identique_u32(void *, uint32_t, RustCallStatus*);
++  int64_t rondpoint_33e7_Retourneur_identique_i64(void *, int64_t, RustCallStatus*);
++  uint64_t rondpoint_33e7_Retourneur_identique_u64(void *, uint64_t, RustCallStatus*);
++  float rondpoint_33e7_Retourneur_identique_float(void *, float, RustCallStatus*);
++  double rondpoint_33e7_Retourneur_identique_double(void *, double, RustCallStatus*);
++  int8_t rondpoint_33e7_Retourneur_identique_boolean(void *, int8_t, RustCallStatus*);
++  RustBuffer rondpoint_33e7_Retourneur_identique_string(void *, RustBuffer, RustCallStatus*);
++  RustBuffer rondpoint_33e7_Retourneur_identique_nombres_signes(void *, RustBuffer, RustCallStatus*);
++  RustBuffer rondpoint_33e7_Retourneur_identique_nombres(void *, RustBuffer, RustCallStatus*);
++  RustBuffer rondpoint_33e7_Retourneur_identique_optionneur_dictionnaire(void *, RustBuffer, RustCallStatus*);
++  void ffi_rondpoint_33e7_Stringifier_object_free(void *, RustCallStatus*);
++  void * rondpoint_33e7_Stringifier_new(RustCallStatus*);
++  RustBuffer rondpoint_33e7_Stringifier_well_known_string(void *, RustBuffer, RustCallStatus*);
++  RustBuffer rondpoint_33e7_Stringifier_to_string_i8(void *, int8_t, RustCallStatus*);
++  RustBuffer rondpoint_33e7_Stringifier_to_string_u8(void *, uint8_t, RustCallStatus*);
++  RustBuffer rondpoint_33e7_Stringifier_to_string_i16(void *, int16_t, RustCallStatus*);
++  RustBuffer rondpoint_33e7_Stringifier_to_string_u16(void *, uint16_t, RustCallStatus*);
++  RustBuffer rondpoint_33e7_Stringifier_to_string_i32(void *, int32_t, RustCallStatus*);
++  RustBuffer rondpoint_33e7_Stringifier_to_string_u32(void *, uint32_t, RustCallStatus*);
++  RustBuffer rondpoint_33e7_Stringifier_to_string_i64(void *, int64_t, RustCallStatus*);
++  RustBuffer rondpoint_33e7_Stringifier_to_string_u64(void *, uint64_t, RustCallStatus*);
++  RustBuffer rondpoint_33e7_Stringifier_to_string_float(void *, float, RustCallStatus*);
++  RustBuffer rondpoint_33e7_Stringifier_to_string_double(void *, double, RustCallStatus*);
++  RustBuffer rondpoint_33e7_Stringifier_to_string_boolean(void *, int8_t, RustCallStatus*);
++  void ffi_rondpoint_33e7_Optionneur_object_free(void *, RustCallStatus*);
++  void * rondpoint_33e7_Optionneur_new(RustCallStatus*);
++  int8_t rondpoint_33e7_Optionneur_sinon_boolean(void *, int8_t, RustCallStatus*);
++  RustBuffer rondpoint_33e7_Optionneur_sinon_string(void *, RustBuffer, RustCallStatus*);
++  RustBuffer rondpoint_33e7_Optionneur_sinon_sequence(void *, RustBuffer, RustCallStatus*);
++  RustBuffer rondpoint_33e7_Optionneur_sinon_null(void *, RustBuffer, RustCallStatus*);
++  RustBuffer rondpoint_33e7_Optionneur_sinon_zero(void *, RustBuffer, RustCallStatus*);
++  uint8_t rondpoint_33e7_Optionneur_sinon_u8_dec(void *, uint8_t, RustCallStatus*);
++  int8_t rondpoint_33e7_Optionneur_sinon_i8_dec(void *, int8_t, RustCallStatus*);
++  uint16_t rondpoint_33e7_Optionneur_sinon_u16_dec(void *, uint16_t, RustCallStatus*);
++  int16_t rondpoint_33e7_Optionneur_sinon_i16_dec(void *, int16_t, RustCallStatus*);
++  uint32_t rondpoint_33e7_Optionneur_sinon_u32_dec(void *, uint32_t, RustCallStatus*);
++  int32_t rondpoint_33e7_Optionneur_sinon_i32_dec(void *, int32_t, RustCallStatus*);
++  uint64_t rondpoint_33e7_Optionneur_sinon_u64_dec(void *, uint64_t, RustCallStatus*);
++  int64_t rondpoint_33e7_Optionneur_sinon_i64_dec(void *, int64_t, RustCallStatus*);
++  uint8_t rondpoint_33e7_Optionneur_sinon_u8_hex(void *, uint8_t, RustCallStatus*);
++  int8_t rondpoint_33e7_Optionneur_sinon_i8_hex(void *, int8_t, RustCallStatus*);
++  uint16_t rondpoint_33e7_Optionneur_sinon_u16_hex(void *, uint16_t, RustCallStatus*);
++  int16_t rondpoint_33e7_Optionneur_sinon_i16_hex(void *, int16_t, RustCallStatus*);
++  uint32_t rondpoint_33e7_Optionneur_sinon_u32_hex(void *, uint32_t, RustCallStatus*);
++  int32_t rondpoint_33e7_Optionneur_sinon_i32_hex(void *, int32_t, RustCallStatus*);
++  uint64_t rondpoint_33e7_Optionneur_sinon_u64_hex(void *, uint64_t, RustCallStatus*);
++  int64_t rondpoint_33e7_Optionneur_sinon_i64_hex(void *, int64_t, RustCallStatus*);
++  uint32_t rondpoint_33e7_Optionneur_sinon_u32_oct(void *, uint32_t, RustCallStatus*);
++  float rondpoint_33e7_Optionneur_sinon_f32(void *, float, RustCallStatus*);
++  double rondpoint_33e7_Optionneur_sinon_f64(void *, double, RustCallStatus*);
++  RustBuffer rondpoint_33e7_Optionneur_sinon_enum(void *, RustBuffer, RustCallStatus*);
++  RustBuffer rondpoint_33e7_copie_dictionnaire(RustBuffer, RustCallStatus*);
++  RustBuffer rondpoint_33e7_copie_enumeration(RustBuffer, RustCallStatus*);
++  RustBuffer rondpoint_33e7_copie_enumerations(RustBuffer, RustCallStatus*);
++  RustBuffer rondpoint_33e7_copie_carte(RustBuffer, RustCallStatus*);
++  int8_t rondpoint_33e7_switcheroo(int8_t, RustCallStatus*);
++  void ffi_sprites_a679_Sprite_object_free(void *, RustCallStatus*);
++  void * sprites_a679_Sprite_new(RustBuffer, RustCallStatus*);
++  void * sprites_a679_Sprite_new_relative_to(RustBuffer, RustBuffer, RustCallStatus*);
++  RustBuffer sprites_a679_Sprite_get_position(void *, RustCallStatus*);
++  void sprites_a679_Sprite_move_to(void *, RustBuffer, RustCallStatus*);
++  void sprites_a679_Sprite_move_by(void *, RustBuffer, RustCallStatus*);
++  RustBuffer sprites_a679_translate(RustBuffer, RustBuffer, RustCallStatus*);
++  void ffi_todolist_cd5b_TodoList_object_free(void *, RustCallStatus*);
++  void * todolist_cd5b_TodoList_new(RustCallStatus*);
++  void todolist_cd5b_TodoList_add_item(void *, RustBuffer, RustCallStatus*);
++  void todolist_cd5b_TodoList_add_entry(void *, RustBuffer, RustCallStatus*);
++  RustBuffer todolist_cd5b_TodoList_get_entries(void *, RustCallStatus*);
++  RustBuffer todolist_cd5b_TodoList_get_items(void *, RustCallStatus*);
++  void todolist_cd5b_TodoList_add_entries(void *, RustBuffer, RustCallStatus*);
++  void todolist_cd5b_TodoList_add_items(void *, RustBuffer, RustCallStatus*);
++  RustBuffer todolist_cd5b_TodoList_get_last_entry(void *, RustCallStatus*);
++  RustBuffer todolist_cd5b_TodoList_get_last(void *, RustCallStatus*);
++  RustBuffer todolist_cd5b_TodoList_get_first(void *, RustCallStatus*);
++  void todolist_cd5b_TodoList_clear_item(void *, RustBuffer, RustCallStatus*);
++  void todolist_cd5b_TodoList_make_default(void *, RustCallStatus*);
++  RustBuffer todolist_cd5b_get_default_list(RustCallStatus*);
++  void todolist_cd5b_set_default_list(void *, RustCallStatus*);
++  RustBuffer todolist_cd5b_create_entry_with(RustBuffer, RustCallStatus*);
++  RustBuffer custom_types_41fc_get_custom_types_demo(RustBuffer, RustCallStatus*);
++  double external_types_4cd4_gradient(RustBuffer, RustCallStatus*);
+ }
+ 
+ // Define pointer types
+ const static mozilla::uniffi::UniFFIPointerType kRondpointRetourneurPointerType {
+   "rondpoint::Retourneur"_ns,
+-  ffi_rondpoint_c6ef_Retourneur_object_free
++  ffi_rondpoint_33e7_Retourneur_object_free
+ };
+ const static mozilla::uniffi::UniFFIPointerType kRondpointStringifierPointerType {
+   "rondpoint::Stringifier"_ns,
+-  ffi_rondpoint_c6ef_Stringifier_object_free
++  ffi_rondpoint_33e7_Stringifier_object_free
+ };
+ const static mozilla::uniffi::UniFFIPointerType kRondpointOptionneurPointerType {
+   "rondpoint::Optionneur"_ns,
+-  ffi_rondpoint_c6ef_Optionneur_object_free
++  ffi_rondpoint_33e7_Optionneur_object_free
+ };
+ const static mozilla::uniffi::UniFFIPointerType kSpritesSpritePointerType {
+   "sprites::Sprite"_ns,
+-  ffi_sprites_accb_Sprite_object_free
++  ffi_sprites_a679_Sprite_object_free
+ };
+ const static mozilla::uniffi::UniFFIPointerType kTodolistTodoListPointerType {
+   "todolist::TodoList"_ns,
+-  ffi_todolist_aa33_TodoList_object_free
++  ffi_todolist_cd5b_TodoList_object_free
+ };
+ 
+ Maybe<already_AddRefed<Promise>> UniFFIFixturesCallAsync(const GlobalObject& aGlobal, uint64_t aId, const Sequence<ScaffoldingType>& aArgs, ErrorResult& aError) {
+   switch (aId) {
+-    case 20: { // geometry:geometry_1cce_gradient
++    case 20: { // geometry:geometry_deb7_gradient
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<double>, ScaffoldingConverter<RustBuffer>>;
+-      return Some(CallHandler::CallAsync(geometry_1cce_gradient, aGlobal, aArgs, "geometry_1cce_gradient: "_ns, aError));
++      return Some(CallHandler::CallAsync(geometry_deb7_gradient, aGlobal, aArgs, "geometry_deb7_gradient: "_ns, aError));
+     }
+-    case 21: { // geometry:geometry_1cce_intersection
++    case 21: { // geometry:geometry_deb7_intersection
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingConverter<RustBuffer>, ScaffoldingConverter<RustBuffer>>;
+-      return Some(CallHandler::CallAsync(geometry_1cce_intersection, aGlobal, aArgs, "geometry_1cce_intersection: "_ns, aError));
++      return Some(CallHandler::CallAsync(geometry_deb7_intersection, aGlobal, aArgs, "geometry_deb7_intersection: "_ns, aError));
+     }
+-    case 22: { // arithmetic:arithmetic_906c_add
++    case 22: { // arithmetic:arithmetic_be49_add
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<uint64_t>, ScaffoldingConverter<uint64_t>, ScaffoldingConverter<uint64_t>>;
+-      return Some(CallHandler::CallAsync(arithmetic_906c_add, aGlobal, aArgs, "arithmetic_906c_add: "_ns, aError));
++      return Some(CallHandler::CallAsync(arithmetic_be49_add, aGlobal, aArgs, "arithmetic_be49_add: "_ns, aError));
+     }
+-    case 23: { // arithmetic:arithmetic_906c_sub
++    case 23: { // arithmetic:arithmetic_be49_sub
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<uint64_t>, ScaffoldingConverter<uint64_t>, ScaffoldingConverter<uint64_t>>;
+-      return Some(CallHandler::CallAsync(arithmetic_906c_sub, aGlobal, aArgs, "arithmetic_906c_sub: "_ns, aError));
++      return Some(CallHandler::CallAsync(arithmetic_be49_sub, aGlobal, aArgs, "arithmetic_be49_sub: "_ns, aError));
+     }
+-    case 24: { // arithmetic:arithmetic_906c_div
++    case 24: { // arithmetic:arithmetic_be49_div
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<uint64_t>, ScaffoldingConverter<uint64_t>, ScaffoldingConverter<uint64_t>>;
+-      return Some(CallHandler::CallAsync(arithmetic_906c_div, aGlobal, aArgs, "arithmetic_906c_div: "_ns, aError));
++      return Some(CallHandler::CallAsync(arithmetic_be49_div, aGlobal, aArgs, "arithmetic_be49_div: "_ns, aError));
+     }
+-    case 25: { // arithmetic:arithmetic_906c_equal
++    case 25: { // arithmetic:arithmetic_be49_equal
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<int8_t>, ScaffoldingConverter<uint64_t>, ScaffoldingConverter<uint64_t>>;
+-      return Some(CallHandler::CallAsync(arithmetic_906c_equal, aGlobal, aArgs, "arithmetic_906c_equal: "_ns, aError));
++      return Some(CallHandler::CallAsync(arithmetic_be49_equal, aGlobal, aArgs, "arithmetic_be49_equal: "_ns, aError));
+     }
+-    case 26: { // rondpoint:rondpoint_c6ef_Retourneur_new
++    case 26: { // rondpoint:rondpoint_33e7_Retourneur_new
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>>;
+-      return Some(CallHandler::CallAsync(rondpoint_c6ef_Retourneur_new, aGlobal, aArgs, "rondpoint_c6ef_Retourneur_new: "_ns, aError));
++      return Some(CallHandler::CallAsync(rondpoint_33e7_Retourneur_new, aGlobal, aArgs, "rondpoint_33e7_Retourneur_new: "_ns, aError));
+     }
+-    case 27: { // rondpoint:rondpoint_c6ef_Retourneur_identique_i8
++    case 27: { // rondpoint:rondpoint_33e7_Retourneur_identique_i8
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<int8_t>, ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>, ScaffoldingConverter<int8_t>>;
+-      return Some(CallHandler::CallAsync(rondpoint_c6ef_Retourneur_identique_i8, aGlobal, aArgs, "rondpoint_c6ef_Retourneur_identique_i8: "_ns, aError));
++      return Some(CallHandler::CallAsync(rondpoint_33e7_Retourneur_identique_i8, aGlobal, aArgs, "rondpoint_33e7_Retourneur_identique_i8: "_ns, aError));
+     }
+-    case 28: { // rondpoint:rondpoint_c6ef_Retourneur_identique_u8
++    case 28: { // rondpoint:rondpoint_33e7_Retourneur_identique_u8
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<uint8_t>, ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>, ScaffoldingConverter<uint8_t>>;
+-      return Some(CallHandler::CallAsync(rondpoint_c6ef_Retourneur_identique_u8, aGlobal, aArgs, "rondpoint_c6ef_Retourneur_identique_u8: "_ns, aError));
++      return Some(CallHandler::CallAsync(rondpoint_33e7_Retourneur_identique_u8, aGlobal, aArgs, "rondpoint_33e7_Retourneur_identique_u8: "_ns, aError));
+     }
+-    case 29: { // rondpoint:rondpoint_c6ef_Retourneur_identique_i16
++    case 29: { // rondpoint:rondpoint_33e7_Retourneur_identique_i16
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<int16_t>, ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>, ScaffoldingConverter<int16_t>>;
+-      return Some(CallHandler::CallAsync(rondpoint_c6ef_Retourneur_identique_i16, aGlobal, aArgs, "rondpoint_c6ef_Retourneur_identique_i16: "_ns, aError));
++      return Some(CallHandler::CallAsync(rondpoint_33e7_Retourneur_identique_i16, aGlobal, aArgs, "rondpoint_33e7_Retourneur_identique_i16: "_ns, aError));
+     }
+-    case 30: { // rondpoint:rondpoint_c6ef_Retourneur_identique_u16
++    case 30: { // rondpoint:rondpoint_33e7_Retourneur_identique_u16
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<uint16_t>, ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>, ScaffoldingConverter<uint16_t>>;
+-      return Some(CallHandler::CallAsync(rondpoint_c6ef_Retourneur_identique_u16, aGlobal, aArgs, "rondpoint_c6ef_Retourneur_identique_u16: "_ns, aError));
++      return Some(CallHandler::CallAsync(rondpoint_33e7_Retourneur_identique_u16, aGlobal, aArgs, "rondpoint_33e7_Retourneur_identique_u16: "_ns, aError));
+     }
+-    case 31: { // rondpoint:rondpoint_c6ef_Retourneur_identique_i32
++    case 31: { // rondpoint:rondpoint_33e7_Retourneur_identique_i32
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<int32_t>, ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>, ScaffoldingConverter<int32_t>>;
+-      return Some(CallHandler::CallAsync(rondpoint_c6ef_Retourneur_identique_i32, aGlobal, aArgs, "rondpoint_c6ef_Retourneur_identique_i32: "_ns, aError));
++      return Some(CallHandler::CallAsync(rondpoint_33e7_Retourneur_identique_i32, aGlobal, aArgs, "rondpoint_33e7_Retourneur_identique_i32: "_ns, aError));
+     }
+-    case 32: { // rondpoint:rondpoint_c6ef_Retourneur_identique_u32
++    case 32: { // rondpoint:rondpoint_33e7_Retourneur_identique_u32
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<uint32_t>, ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>, ScaffoldingConverter<uint32_t>>;
+-      return Some(CallHandler::CallAsync(rondpoint_c6ef_Retourneur_identique_u32, aGlobal, aArgs, "rondpoint_c6ef_Retourneur_identique_u32: "_ns, aError));
++      return Some(CallHandler::CallAsync(rondpoint_33e7_Retourneur_identique_u32, aGlobal, aArgs, "rondpoint_33e7_Retourneur_identique_u32: "_ns, aError));
+     }
+-    case 33: { // rondpoint:rondpoint_c6ef_Retourneur_identique_i64
++    case 33: { // rondpoint:rondpoint_33e7_Retourneur_identique_i64
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<int64_t>, ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>, ScaffoldingConverter<int64_t>>;
+-      return Some(CallHandler::CallAsync(rondpoint_c6ef_Retourneur_identique_i64, aGlobal, aArgs, "rondpoint_c6ef_Retourneur_identique_i64: "_ns, aError));
++      return Some(CallHandler::CallAsync(rondpoint_33e7_Retourneur_identique_i64, aGlobal, aArgs, "rondpoint_33e7_Retourneur_identique_i64: "_ns, aError));
+     }
+-    case 34: { // rondpoint:rondpoint_c6ef_Retourneur_identique_u64
++    case 34: { // rondpoint:rondpoint_33e7_Retourneur_identique_u64
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<uint64_t>, ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>, ScaffoldingConverter<uint64_t>>;
+-      return Some(CallHandler::CallAsync(rondpoint_c6ef_Retourneur_identique_u64, aGlobal, aArgs, "rondpoint_c6ef_Retourneur_identique_u64: "_ns, aError));
++      return Some(CallHandler::CallAsync(rondpoint_33e7_Retourneur_identique_u64, aGlobal, aArgs, "rondpoint_33e7_Retourneur_identique_u64: "_ns, aError));
+     }
+-    case 35: { // rondpoint:rondpoint_c6ef_Retourneur_identique_float
++    case 35: { // rondpoint:rondpoint_33e7_Retourneur_identique_float
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<float>, ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>, ScaffoldingConverter<float>>;
+-      return Some(CallHandler::CallAsync(rondpoint_c6ef_Retourneur_identique_float, aGlobal, aArgs, "rondpoint_c6ef_Retourneur_identique_float: "_ns, aError));
++      return Some(CallHandler::CallAsync(rondpoint_33e7_Retourneur_identique_float, aGlobal, aArgs, "rondpoint_33e7_Retourneur_identique_float: "_ns, aError));
+     }
+-    case 36: { // rondpoint:rondpoint_c6ef_Retourneur_identique_double
++    case 36: { // rondpoint:rondpoint_33e7_Retourneur_identique_double
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<double>, ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>, ScaffoldingConverter<double>>;
+-      return Some(CallHandler::CallAsync(rondpoint_c6ef_Retourneur_identique_double, aGlobal, aArgs, "rondpoint_c6ef_Retourneur_identique_double: "_ns, aError));
++      return Some(CallHandler::CallAsync(rondpoint_33e7_Retourneur_identique_double, aGlobal, aArgs, "rondpoint_33e7_Retourneur_identique_double: "_ns, aError));
+     }
+-    case 37: { // rondpoint:rondpoint_c6ef_Retourneur_identique_boolean
++    case 37: { // rondpoint:rondpoint_33e7_Retourneur_identique_boolean
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<int8_t>, ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>, ScaffoldingConverter<int8_t>>;
+-      return Some(CallHandler::CallAsync(rondpoint_c6ef_Retourneur_identique_boolean, aGlobal, aArgs, "rondpoint_c6ef_Retourneur_identique_boolean: "_ns, aError));
++      return Some(CallHandler::CallAsync(rondpoint_33e7_Retourneur_identique_boolean, aGlobal, aArgs, "rondpoint_33e7_Retourneur_identique_boolean: "_ns, aError));
+     }
+-    case 38: { // rondpoint:rondpoint_c6ef_Retourneur_identique_string
++    case 38: { // rondpoint:rondpoint_33e7_Retourneur_identique_string
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>, ScaffoldingConverter<RustBuffer>>;
+-      return Some(CallHandler::CallAsync(rondpoint_c6ef_Retourneur_identique_string, aGlobal, aArgs, "rondpoint_c6ef_Retourneur_identique_string: "_ns, aError));
++      return Some(CallHandler::CallAsync(rondpoint_33e7_Retourneur_identique_string, aGlobal, aArgs, "rondpoint_33e7_Retourneur_identique_string: "_ns, aError));
+     }
+-    case 39: { // rondpoint:rondpoint_c6ef_Retourneur_identique_nombres_signes
++    case 39: { // rondpoint:rondpoint_33e7_Retourneur_identique_nombres_signes
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>, ScaffoldingConverter<RustBuffer>>;
+-      return Some(CallHandler::CallAsync(rondpoint_c6ef_Retourneur_identique_nombres_signes, aGlobal, aArgs, "rondpoint_c6ef_Retourneur_identique_nombres_signes: "_ns, aError));
++      return Some(CallHandler::CallAsync(rondpoint_33e7_Retourneur_identique_nombres_signes, aGlobal, aArgs, "rondpoint_33e7_Retourneur_identique_nombres_signes: "_ns, aError));
+     }
+-    case 40: { // rondpoint:rondpoint_c6ef_Retourneur_identique_nombres
++    case 40: { // rondpoint:rondpoint_33e7_Retourneur_identique_nombres
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>, ScaffoldingConverter<RustBuffer>>;
+-      return Some(CallHandler::CallAsync(rondpoint_c6ef_Retourneur_identique_nombres, aGlobal, aArgs, "rondpoint_c6ef_Retourneur_identique_nombres: "_ns, aError));
++      return Some(CallHandler::CallAsync(rondpoint_33e7_Retourneur_identique_nombres, aGlobal, aArgs, "rondpoint_33e7_Retourneur_identique_nombres: "_ns, aError));
+     }
+-    case 41: { // rondpoint:rondpoint_c6ef_Retourneur_identique_optionneur_dictionnaire
++    case 41: { // rondpoint:rondpoint_33e7_Retourneur_identique_optionneur_dictionnaire
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>, ScaffoldingConverter<RustBuffer>>;
+-      return Some(CallHandler::CallAsync(rondpoint_c6ef_Retourneur_identique_optionneur_dictionnaire, aGlobal, aArgs, "rondpoint_c6ef_Retourneur_identique_optionneur_dictionnaire: "_ns, aError));
++      return Some(CallHandler::CallAsync(rondpoint_33e7_Retourneur_identique_optionneur_dictionnaire, aGlobal, aArgs, "rondpoint_33e7_Retourneur_identique_optionneur_dictionnaire: "_ns, aError));
+     }
+-    case 42: { // rondpoint:rondpoint_c6ef_Stringifier_new
++    case 42: { // rondpoint:rondpoint_33e7_Stringifier_new
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingObjectConverter<&kRondpointStringifierPointerType>>;
+-      return Some(CallHandler::CallAsync(rondpoint_c6ef_Stringifier_new, aGlobal, aArgs, "rondpoint_c6ef_Stringifier_new: "_ns, aError));
++      return Some(CallHandler::CallAsync(rondpoint_33e7_Stringifier_new, aGlobal, aArgs, "rondpoint_33e7_Stringifier_new: "_ns, aError));
+     }
+-    case 43: { // rondpoint:rondpoint_c6ef_Stringifier_well_known_string
++    case 43: { // rondpoint:rondpoint_33e7_Stringifier_well_known_string
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kRondpointStringifierPointerType>, ScaffoldingConverter<RustBuffer>>;
+-      return Some(CallHandler::CallAsync(rondpoint_c6ef_Stringifier_well_known_string, aGlobal, aArgs, "rondpoint_c6ef_Stringifier_well_known_string: "_ns, aError));
++      return Some(CallHandler::CallAsync(rondpoint_33e7_Stringifier_well_known_string, aGlobal, aArgs, "rondpoint_33e7_Stringifier_well_known_string: "_ns, aError));
+     }
+-    case 44: { // rondpoint:rondpoint_c6ef_Stringifier_to_string_i8
++    case 44: { // rondpoint:rondpoint_33e7_Stringifier_to_string_i8
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kRondpointStringifierPointerType>, ScaffoldingConverter<int8_t>>;
+-      return Some(CallHandler::CallAsync(rondpoint_c6ef_Stringifier_to_string_i8, aGlobal, aArgs, "rondpoint_c6ef_Stringifier_to_string_i8: "_ns, aError));
++      return Some(CallHandler::CallAsync(rondpoint_33e7_Stringifier_to_string_i8, aGlobal, aArgs, "rondpoint_33e7_Stringifier_to_string_i8: "_ns, aError));
+     }
+-    case 45: { // rondpoint:rondpoint_c6ef_Stringifier_to_string_u8
++    case 45: { // rondpoint:rondpoint_33e7_Stringifier_to_string_u8
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kRondpointStringifierPointerType>, ScaffoldingConverter<uint8_t>>;
+-      return Some(CallHandler::CallAsync(rondpoint_c6ef_Stringifier_to_string_u8, aGlobal, aArgs, "rondpoint_c6ef_Stringifier_to_string_u8: "_ns, aError));
++      return Some(CallHandler::CallAsync(rondpoint_33e7_Stringifier_to_string_u8, aGlobal, aArgs, "rondpoint_33e7_Stringifier_to_string_u8: "_ns, aError));
+     }
+-    case 46: { // rondpoint:rondpoint_c6ef_Stringifier_to_string_i16
++    case 46: { // rondpoint:rondpoint_33e7_Stringifier_to_string_i16
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kRondpointStringifierPointerType>, ScaffoldingConverter<int16_t>>;
+-      return Some(CallHandler::CallAsync(rondpoint_c6ef_Stringifier_to_string_i16, aGlobal, aArgs, "rondpoint_c6ef_Stringifier_to_string_i16: "_ns, aError));
++      return Some(CallHandler::CallAsync(rondpoint_33e7_Stringifier_to_string_i16, aGlobal, aArgs, "rondpoint_33e7_Stringifier_to_string_i16: "_ns, aError));
+     }
+-    case 47: { // rondpoint:rondpoint_c6ef_Stringifier_to_string_u16
++    case 47: { // rondpoint:rondpoint_33e7_Stringifier_to_string_u16
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kRondpointStringifierPointerType>, ScaffoldingConverter<uint16_t>>;
+-      return Some(CallHandler::CallAsync(rondpoint_c6ef_Stringifier_to_string_u16, aGlobal, aArgs, "rondpoint_c6ef_Stringifier_to_string_u16: "_ns, aError));
++      return Some(CallHandler::CallAsync(rondpoint_33e7_Stringifier_to_string_u16, aGlobal, aArgs, "rondpoint_33e7_Stringifier_to_string_u16: "_ns, aError));
+     }
+-    case 48: { // rondpoint:rondpoint_c6ef_Stringifier_to_string_i32
++    case 48: { // rondpoint:rondpoint_33e7_Stringifier_to_string_i32
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kRondpointStringifierPointerType>, ScaffoldingConverter<int32_t>>;
+-      return Some(CallHandler::CallAsync(rondpoint_c6ef_Stringifier_to_string_i32, aGlobal, aArgs, "rondpoint_c6ef_Stringifier_to_string_i32: "_ns, aError));
++      return Some(CallHandler::CallAsync(rondpoint_33e7_Stringifier_to_string_i32, aGlobal, aArgs, "rondpoint_33e7_Stringifier_to_string_i32: "_ns, aError));
+     }
+-    case 49: { // rondpoint:rondpoint_c6ef_Stringifier_to_string_u32
++    case 49: { // rondpoint:rondpoint_33e7_Stringifier_to_string_u32
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kRondpointStringifierPointerType>, ScaffoldingConverter<uint32_t>>;
+-      return Some(CallHandler::CallAsync(rondpoint_c6ef_Stringifier_to_string_u32, aGlobal, aArgs, "rondpoint_c6ef_Stringifier_to_string_u32: "_ns, aError));
++      return Some(CallHandler::CallAsync(rondpoint_33e7_Stringifier_to_string_u32, aGlobal, aArgs, "rondpoint_33e7_Stringifier_to_string_u32: "_ns, aError));
+     }
+-    case 50: { // rondpoint:rondpoint_c6ef_Stringifier_to_string_i64
++    case 50: { // rondpoint:rondpoint_33e7_Stringifier_to_string_i64
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kRondpointStringifierPointerType>, ScaffoldingConverter<int64_t>>;
+-      return Some(CallHandler::CallAsync(rondpoint_c6ef_Stringifier_to_string_i64, aGlobal, aArgs, "rondpoint_c6ef_Stringifier_to_string_i64: "_ns, aError));
++      return Some(CallHandler::CallAsync(rondpoint_33e7_Stringifier_to_string_i64, aGlobal, aArgs, "rondpoint_33e7_Stringifier_to_string_i64: "_ns, aError));
+     }
+-    case 51: { // rondpoint:rondpoint_c6ef_Stringifier_to_string_u64
++    case 51: { // rondpoint:rondpoint_33e7_Stringifier_to_string_u64
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kRondpointStringifierPointerType>, ScaffoldingConverter<uint64_t>>;
+-      return Some(CallHandler::CallAsync(rondpoint_c6ef_Stringifier_to_string_u64, aGlobal, aArgs, "rondpoint_c6ef_Stringifier_to_string_u64: "_ns, aError));
++      return Some(CallHandler::CallAsync(rondpoint_33e7_Stringifier_to_string_u64, aGlobal, aArgs, "rondpoint_33e7_Stringifier_to_string_u64: "_ns, aError));
+     }
+-    case 52: { // rondpoint:rondpoint_c6ef_Stringifier_to_string_float
++    case 52: { // rondpoint:rondpoint_33e7_Stringifier_to_string_float
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kRondpointStringifierPointerType>, ScaffoldingConverter<float>>;
+-      return Some(CallHandler::CallAsync(rondpoint_c6ef_Stringifier_to_string_float, aGlobal, aArgs, "rondpoint_c6ef_Stringifier_to_string_float: "_ns, aError));
++      return Some(CallHandler::CallAsync(rondpoint_33e7_Stringifier_to_string_float, aGlobal, aArgs, "rondpoint_33e7_Stringifier_to_string_float: "_ns, aError));
+     }
+-    case 53: { // rondpoint:rondpoint_c6ef_Stringifier_to_string_double
++    case 53: { // rondpoint:rondpoint_33e7_Stringifier_to_string_double
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kRondpointStringifierPointerType>, ScaffoldingConverter<double>>;
+-      return Some(CallHandler::CallAsync(rondpoint_c6ef_Stringifier_to_string_double, aGlobal, aArgs, "rondpoint_c6ef_Stringifier_to_string_double: "_ns, aError));
++      return Some(CallHandler::CallAsync(rondpoint_33e7_Stringifier_to_string_double, aGlobal, aArgs, "rondpoint_33e7_Stringifier_to_string_double: "_ns, aError));
+     }
+-    case 54: { // rondpoint:rondpoint_c6ef_Stringifier_to_string_boolean
++    case 54: { // rondpoint:rondpoint_33e7_Stringifier_to_string_boolean
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kRondpointStringifierPointerType>, ScaffoldingConverter<int8_t>>;
+-      return Some(CallHandler::CallAsync(rondpoint_c6ef_Stringifier_to_string_boolean, aGlobal, aArgs, "rondpoint_c6ef_Stringifier_to_string_boolean: "_ns, aError));
++      return Some(CallHandler::CallAsync(rondpoint_33e7_Stringifier_to_string_boolean, aGlobal, aArgs, "rondpoint_33e7_Stringifier_to_string_boolean: "_ns, aError));
+     }
+-    case 55: { // rondpoint:rondpoint_c6ef_Optionneur_new
++    case 55: { // rondpoint:rondpoint_33e7_Optionneur_new
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>>;
+-      return Some(CallHandler::CallAsync(rondpoint_c6ef_Optionneur_new, aGlobal, aArgs, "rondpoint_c6ef_Optionneur_new: "_ns, aError));
++      return Some(CallHandler::CallAsync(rondpoint_33e7_Optionneur_new, aGlobal, aArgs, "rondpoint_33e7_Optionneur_new: "_ns, aError));
+     }
+-    case 56: { // rondpoint:rondpoint_c6ef_Optionneur_sinon_boolean
++    case 56: { // rondpoint:rondpoint_33e7_Optionneur_sinon_boolean
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<int8_t>, ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>, ScaffoldingConverter<int8_t>>;
+-      return Some(CallHandler::CallAsync(rondpoint_c6ef_Optionneur_sinon_boolean, aGlobal, aArgs, "rondpoint_c6ef_Optionneur_sinon_boolean: "_ns, aError));
++      return Some(CallHandler::CallAsync(rondpoint_33e7_Optionneur_sinon_boolean, aGlobal, aArgs, "rondpoint_33e7_Optionneur_sinon_boolean: "_ns, aError));
+     }
+-    case 57: { // rondpoint:rondpoint_c6ef_Optionneur_sinon_string
++    case 57: { // rondpoint:rondpoint_33e7_Optionneur_sinon_string
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>, ScaffoldingConverter<RustBuffer>>;
+-      return Some(CallHandler::CallAsync(rondpoint_c6ef_Optionneur_sinon_string, aGlobal, aArgs, "rondpoint_c6ef_Optionneur_sinon_string: "_ns, aError));
++      return Some(CallHandler::CallAsync(rondpoint_33e7_Optionneur_sinon_string, aGlobal, aArgs, "rondpoint_33e7_Optionneur_sinon_string: "_ns, aError));
+     }
+-    case 58: { // rondpoint:rondpoint_c6ef_Optionneur_sinon_sequence
++    case 58: { // rondpoint:rondpoint_33e7_Optionneur_sinon_sequence
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>, ScaffoldingConverter<RustBuffer>>;
+-      return Some(CallHandler::CallAsync(rondpoint_c6ef_Optionneur_sinon_sequence, aGlobal, aArgs, "rondpoint_c6ef_Optionneur_sinon_sequence: "_ns, aError));
++      return Some(CallHandler::CallAsync(rondpoint_33e7_Optionneur_sinon_sequence, aGlobal, aArgs, "rondpoint_33e7_Optionneur_sinon_sequence: "_ns, aError));
+     }
+-    case 59: { // rondpoint:rondpoint_c6ef_Optionneur_sinon_null
++    case 59: { // rondpoint:rondpoint_33e7_Optionneur_sinon_null
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>, ScaffoldingConverter<RustBuffer>>;
+-      return Some(CallHandler::CallAsync(rondpoint_c6ef_Optionneur_sinon_null, aGlobal, aArgs, "rondpoint_c6ef_Optionneur_sinon_null: "_ns, aError));
++      return Some(CallHandler::CallAsync(rondpoint_33e7_Optionneur_sinon_null, aGlobal, aArgs, "rondpoint_33e7_Optionneur_sinon_null: "_ns, aError));
+     }
+-    case 60: { // rondpoint:rondpoint_c6ef_Optionneur_sinon_zero
++    case 60: { // rondpoint:rondpoint_33e7_Optionneur_sinon_zero
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>, ScaffoldingConverter<RustBuffer>>;
+-      return Some(CallHandler::CallAsync(rondpoint_c6ef_Optionneur_sinon_zero, aGlobal, aArgs, "rondpoint_c6ef_Optionneur_sinon_zero: "_ns, aError));
++      return Some(CallHandler::CallAsync(rondpoint_33e7_Optionneur_sinon_zero, aGlobal, aArgs, "rondpoint_33e7_Optionneur_sinon_zero: "_ns, aError));
+     }
+-    case 61: { // rondpoint:rondpoint_c6ef_Optionneur_sinon_u8_dec
++    case 61: { // rondpoint:rondpoint_33e7_Optionneur_sinon_u8_dec
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<uint8_t>, ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>, ScaffoldingConverter<uint8_t>>;
+-      return Some(CallHandler::CallAsync(rondpoint_c6ef_Optionneur_sinon_u8_dec, aGlobal, aArgs, "rondpoint_c6ef_Optionneur_sinon_u8_dec: "_ns, aError));
++      return Some(CallHandler::CallAsync(rondpoint_33e7_Optionneur_sinon_u8_dec, aGlobal, aArgs, "rondpoint_33e7_Optionneur_sinon_u8_dec: "_ns, aError));
+     }
+-    case 62: { // rondpoint:rondpoint_c6ef_Optionneur_sinon_i8_dec
++    case 62: { // rondpoint:rondpoint_33e7_Optionneur_sinon_i8_dec
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<int8_t>, ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>, ScaffoldingConverter<int8_t>>;
+-      return Some(CallHandler::CallAsync(rondpoint_c6ef_Optionneur_sinon_i8_dec, aGlobal, aArgs, "rondpoint_c6ef_Optionneur_sinon_i8_dec: "_ns, aError));
++      return Some(CallHandler::CallAsync(rondpoint_33e7_Optionneur_sinon_i8_dec, aGlobal, aArgs, "rondpoint_33e7_Optionneur_sinon_i8_dec: "_ns, aError));
+     }
+-    case 63: { // rondpoint:rondpoint_c6ef_Optionneur_sinon_u16_dec
++    case 63: { // rondpoint:rondpoint_33e7_Optionneur_sinon_u16_dec
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<uint16_t>, ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>, ScaffoldingConverter<uint16_t>>;
+-      return Some(CallHandler::CallAsync(rondpoint_c6ef_Optionneur_sinon_u16_dec, aGlobal, aArgs, "rondpoint_c6ef_Optionneur_sinon_u16_dec: "_ns, aError));
++      return Some(CallHandler::CallAsync(rondpoint_33e7_Optionneur_sinon_u16_dec, aGlobal, aArgs, "rondpoint_33e7_Optionneur_sinon_u16_dec: "_ns, aError));
+     }
+-    case 64: { // rondpoint:rondpoint_c6ef_Optionneur_sinon_i16_dec
++    case 64: { // rondpoint:rondpoint_33e7_Optionneur_sinon_i16_dec
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<int16_t>, ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>, ScaffoldingConverter<int16_t>>;
+-      return Some(CallHandler::CallAsync(rondpoint_c6ef_Optionneur_sinon_i16_dec, aGlobal, aArgs, "rondpoint_c6ef_Optionneur_sinon_i16_dec: "_ns, aError));
++      return Some(CallHandler::CallAsync(rondpoint_33e7_Optionneur_sinon_i16_dec, aGlobal, aArgs, "rondpoint_33e7_Optionneur_sinon_i16_dec: "_ns, aError));
+     }
+-    case 65: { // rondpoint:rondpoint_c6ef_Optionneur_sinon_u32_dec
++    case 65: { // rondpoint:rondpoint_33e7_Optionneur_sinon_u32_dec
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<uint32_t>, ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>, ScaffoldingConverter<uint32_t>>;
+-      return Some(CallHandler::CallAsync(rondpoint_c6ef_Optionneur_sinon_u32_dec, aGlobal, aArgs, "rondpoint_c6ef_Optionneur_sinon_u32_dec: "_ns, aError));
++      return Some(CallHandler::CallAsync(rondpoint_33e7_Optionneur_sinon_u32_dec, aGlobal, aArgs, "rondpoint_33e7_Optionneur_sinon_u32_dec: "_ns, aError));
+     }
+-    case 66: { // rondpoint:rondpoint_c6ef_Optionneur_sinon_i32_dec
++    case 66: { // rondpoint:rondpoint_33e7_Optionneur_sinon_i32_dec
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<int32_t>, ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>, ScaffoldingConverter<int32_t>>;
+-      return Some(CallHandler::CallAsync(rondpoint_c6ef_Optionneur_sinon_i32_dec, aGlobal, aArgs, "rondpoint_c6ef_Optionneur_sinon_i32_dec: "_ns, aError));
++      return Some(CallHandler::CallAsync(rondpoint_33e7_Optionneur_sinon_i32_dec, aGlobal, aArgs, "rondpoint_33e7_Optionneur_sinon_i32_dec: "_ns, aError));
+     }
+-    case 67: { // rondpoint:rondpoint_c6ef_Optionneur_sinon_u64_dec
++    case 67: { // rondpoint:rondpoint_33e7_Optionneur_sinon_u64_dec
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<uint64_t>, ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>, ScaffoldingConverter<uint64_t>>;
+-      return Some(CallHandler::CallAsync(rondpoint_c6ef_Optionneur_sinon_u64_dec, aGlobal, aArgs, "rondpoint_c6ef_Optionneur_sinon_u64_dec: "_ns, aError));
++      return Some(CallHandler::CallAsync(rondpoint_33e7_Optionneur_sinon_u64_dec, aGlobal, aArgs, "rondpoint_33e7_Optionneur_sinon_u64_dec: "_ns, aError));
+     }
+-    case 68: { // rondpoint:rondpoint_c6ef_Optionneur_sinon_i64_dec
++    case 68: { // rondpoint:rondpoint_33e7_Optionneur_sinon_i64_dec
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<int64_t>, ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>, ScaffoldingConverter<int64_t>>;
+-      return Some(CallHandler::CallAsync(rondpoint_c6ef_Optionneur_sinon_i64_dec, aGlobal, aArgs, "rondpoint_c6ef_Optionneur_sinon_i64_dec: "_ns, aError));
++      return Some(CallHandler::CallAsync(rondpoint_33e7_Optionneur_sinon_i64_dec, aGlobal, aArgs, "rondpoint_33e7_Optionneur_sinon_i64_dec: "_ns, aError));
+     }
+-    case 69: { // rondpoint:rondpoint_c6ef_Optionneur_sinon_u8_hex
++    case 69: { // rondpoint:rondpoint_33e7_Optionneur_sinon_u8_hex
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<uint8_t>, ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>, ScaffoldingConverter<uint8_t>>;
+-      return Some(CallHandler::CallAsync(rondpoint_c6ef_Optionneur_sinon_u8_hex, aGlobal, aArgs, "rondpoint_c6ef_Optionneur_sinon_u8_hex: "_ns, aError));
++      return Some(CallHandler::CallAsync(rondpoint_33e7_Optionneur_sinon_u8_hex, aGlobal, aArgs, "rondpoint_33e7_Optionneur_sinon_u8_hex: "_ns, aError));
+     }
+-    case 70: { // rondpoint:rondpoint_c6ef_Optionneur_sinon_i8_hex
++    case 70: { // rondpoint:rondpoint_33e7_Optionneur_sinon_i8_hex
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<int8_t>, ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>, ScaffoldingConverter<int8_t>>;
+-      return Some(CallHandler::CallAsync(rondpoint_c6ef_Optionneur_sinon_i8_hex, aGlobal, aArgs, "rondpoint_c6ef_Optionneur_sinon_i8_hex: "_ns, aError));
++      return Some(CallHandler::CallAsync(rondpoint_33e7_Optionneur_sinon_i8_hex, aGlobal, aArgs, "rondpoint_33e7_Optionneur_sinon_i8_hex: "_ns, aError));
+     }
+-    case 71: { // rondpoint:rondpoint_c6ef_Optionneur_sinon_u16_hex
++    case 71: { // rondpoint:rondpoint_33e7_Optionneur_sinon_u16_hex
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<uint16_t>, ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>, ScaffoldingConverter<uint16_t>>;
+-      return Some(CallHandler::CallAsync(rondpoint_c6ef_Optionneur_sinon_u16_hex, aGlobal, aArgs, "rondpoint_c6ef_Optionneur_sinon_u16_hex: "_ns, aError));
++      return Some(CallHandler::CallAsync(rondpoint_33e7_Optionneur_sinon_u16_hex, aGlobal, aArgs, "rondpoint_33e7_Optionneur_sinon_u16_hex: "_ns, aError));
+     }
+-    case 72: { // rondpoint:rondpoint_c6ef_Optionneur_sinon_i16_hex
++    case 72: { // rondpoint:rondpoint_33e7_Optionneur_sinon_i16_hex
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<int16_t>, ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>, ScaffoldingConverter<int16_t>>;
+-      return Some(CallHandler::CallAsync(rondpoint_c6ef_Optionneur_sinon_i16_hex, aGlobal, aArgs, "rondpoint_c6ef_Optionneur_sinon_i16_hex: "_ns, aError));
++      return Some(CallHandler::CallAsync(rondpoint_33e7_Optionneur_sinon_i16_hex, aGlobal, aArgs, "rondpoint_33e7_Optionneur_sinon_i16_hex: "_ns, aError));
+     }
+-    case 73: { // rondpoint:rondpoint_c6ef_Optionneur_sinon_u32_hex
++    case 73: { // rondpoint:rondpoint_33e7_Optionneur_sinon_u32_hex
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<uint32_t>, ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>, ScaffoldingConverter<uint32_t>>;
+-      return Some(CallHandler::CallAsync(rondpoint_c6ef_Optionneur_sinon_u32_hex, aGlobal, aArgs, "rondpoint_c6ef_Optionneur_sinon_u32_hex: "_ns, aError));
++      return Some(CallHandler::CallAsync(rondpoint_33e7_Optionneur_sinon_u32_hex, aGlobal, aArgs, "rondpoint_33e7_Optionneur_sinon_u32_hex: "_ns, aError));
+     }
+-    case 74: { // rondpoint:rondpoint_c6ef_Optionneur_sinon_i32_hex
++    case 74: { // rondpoint:rondpoint_33e7_Optionneur_sinon_i32_hex
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<int32_t>, ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>, ScaffoldingConverter<int32_t>>;
+-      return Some(CallHandler::CallAsync(rondpoint_c6ef_Optionneur_sinon_i32_hex, aGlobal, aArgs, "rondpoint_c6ef_Optionneur_sinon_i32_hex: "_ns, aError));
++      return Some(CallHandler::CallAsync(rondpoint_33e7_Optionneur_sinon_i32_hex, aGlobal, aArgs, "rondpoint_33e7_Optionneur_sinon_i32_hex: "_ns, aError));
+     }
+-    case 75: { // rondpoint:rondpoint_c6ef_Optionneur_sinon_u64_hex
++    case 75: { // rondpoint:rondpoint_33e7_Optionneur_sinon_u64_hex
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<uint64_t>, ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>, ScaffoldingConverter<uint64_t>>;
+-      return Some(CallHandler::CallAsync(rondpoint_c6ef_Optionneur_sinon_u64_hex, aGlobal, aArgs, "rondpoint_c6ef_Optionneur_sinon_u64_hex: "_ns, aError));
++      return Some(CallHandler::CallAsync(rondpoint_33e7_Optionneur_sinon_u64_hex, aGlobal, aArgs, "rondpoint_33e7_Optionneur_sinon_u64_hex: "_ns, aError));
+     }
+-    case 76: { // rondpoint:rondpoint_c6ef_Optionneur_sinon_i64_hex
++    case 76: { // rondpoint:rondpoint_33e7_Optionneur_sinon_i64_hex
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<int64_t>, ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>, ScaffoldingConverter<int64_t>>;
+-      return Some(CallHandler::CallAsync(rondpoint_c6ef_Optionneur_sinon_i64_hex, aGlobal, aArgs, "rondpoint_c6ef_Optionneur_sinon_i64_hex: "_ns, aError));
++      return Some(CallHandler::CallAsync(rondpoint_33e7_Optionneur_sinon_i64_hex, aGlobal, aArgs, "rondpoint_33e7_Optionneur_sinon_i64_hex: "_ns, aError));
+     }
+-    case 77: { // rondpoint:rondpoint_c6ef_Optionneur_sinon_u32_oct
++    case 77: { // rondpoint:rondpoint_33e7_Optionneur_sinon_u32_oct
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<uint32_t>, ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>, ScaffoldingConverter<uint32_t>>;
+-      return Some(CallHandler::CallAsync(rondpoint_c6ef_Optionneur_sinon_u32_oct, aGlobal, aArgs, "rondpoint_c6ef_Optionneur_sinon_u32_oct: "_ns, aError));
++      return Some(CallHandler::CallAsync(rondpoint_33e7_Optionneur_sinon_u32_oct, aGlobal, aArgs, "rondpoint_33e7_Optionneur_sinon_u32_oct: "_ns, aError));
+     }
+-    case 78: { // rondpoint:rondpoint_c6ef_Optionneur_sinon_f32
++    case 78: { // rondpoint:rondpoint_33e7_Optionneur_sinon_f32
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<float>, ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>, ScaffoldingConverter<float>>;
+-      return Some(CallHandler::CallAsync(rondpoint_c6ef_Optionneur_sinon_f32, aGlobal, aArgs, "rondpoint_c6ef_Optionneur_sinon_f32: "_ns, aError));
++      return Some(CallHandler::CallAsync(rondpoint_33e7_Optionneur_sinon_f32, aGlobal, aArgs, "rondpoint_33e7_Optionneur_sinon_f32: "_ns, aError));
+     }
+-    case 79: { // rondpoint:rondpoint_c6ef_Optionneur_sinon_f64
++    case 79: { // rondpoint:rondpoint_33e7_Optionneur_sinon_f64
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<double>, ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>, ScaffoldingConverter<double>>;
+-      return Some(CallHandler::CallAsync(rondpoint_c6ef_Optionneur_sinon_f64, aGlobal, aArgs, "rondpoint_c6ef_Optionneur_sinon_f64: "_ns, aError));
++      return Some(CallHandler::CallAsync(rondpoint_33e7_Optionneur_sinon_f64, aGlobal, aArgs, "rondpoint_33e7_Optionneur_sinon_f64: "_ns, aError));
+     }
+-    case 80: { // rondpoint:rondpoint_c6ef_Optionneur_sinon_enum
++    case 80: { // rondpoint:rondpoint_33e7_Optionneur_sinon_enum
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>, ScaffoldingConverter<RustBuffer>>;
+-      return Some(CallHandler::CallAsync(rondpoint_c6ef_Optionneur_sinon_enum, aGlobal, aArgs, "rondpoint_c6ef_Optionneur_sinon_enum: "_ns, aError));
++      return Some(CallHandler::CallAsync(rondpoint_33e7_Optionneur_sinon_enum, aGlobal, aArgs, "rondpoint_33e7_Optionneur_sinon_enum: "_ns, aError));
+     }
+-    case 81: { // rondpoint:rondpoint_c6ef_copie_dictionnaire
++    case 81: { // rondpoint:rondpoint_33e7_copie_dictionnaire
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingConverter<RustBuffer>>;
+-      return Some(CallHandler::CallAsync(rondpoint_c6ef_copie_dictionnaire, aGlobal, aArgs, "rondpoint_c6ef_copie_dictionnaire: "_ns, aError));
++      return Some(CallHandler::CallAsync(rondpoint_33e7_copie_dictionnaire, aGlobal, aArgs, "rondpoint_33e7_copie_dictionnaire: "_ns, aError));
+     }
+-    case 82: { // rondpoint:rondpoint_c6ef_copie_enumeration
++    case 82: { // rondpoint:rondpoint_33e7_copie_enumeration
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingConverter<RustBuffer>>;
+-      return Some(CallHandler::CallAsync(rondpoint_c6ef_copie_enumeration, aGlobal, aArgs, "rondpoint_c6ef_copie_enumeration: "_ns, aError));
++      return Some(CallHandler::CallAsync(rondpoint_33e7_copie_enumeration, aGlobal, aArgs, "rondpoint_33e7_copie_enumeration: "_ns, aError));
+     }
+-    case 83: { // rondpoint:rondpoint_c6ef_copie_enumerations
++    case 83: { // rondpoint:rondpoint_33e7_copie_enumerations
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingConverter<RustBuffer>>;
+-      return Some(CallHandler::CallAsync(rondpoint_c6ef_copie_enumerations, aGlobal, aArgs, "rondpoint_c6ef_copie_enumerations: "_ns, aError));
++      return Some(CallHandler::CallAsync(rondpoint_33e7_copie_enumerations, aGlobal, aArgs, "rondpoint_33e7_copie_enumerations: "_ns, aError));
+     }
+-    case 84: { // rondpoint:rondpoint_c6ef_copie_carte
++    case 84: { // rondpoint:rondpoint_33e7_copie_carte
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingConverter<RustBuffer>>;
+-      return Some(CallHandler::CallAsync(rondpoint_c6ef_copie_carte, aGlobal, aArgs, "rondpoint_c6ef_copie_carte: "_ns, aError));
++      return Some(CallHandler::CallAsync(rondpoint_33e7_copie_carte, aGlobal, aArgs, "rondpoint_33e7_copie_carte: "_ns, aError));
+     }
+-    case 85: { // rondpoint:rondpoint_c6ef_switcheroo
++    case 85: { // rondpoint:rondpoint_33e7_switcheroo
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<int8_t>, ScaffoldingConverter<int8_t>>;
+-      return Some(CallHandler::CallAsync(rondpoint_c6ef_switcheroo, aGlobal, aArgs, "rondpoint_c6ef_switcheroo: "_ns, aError));
++      return Some(CallHandler::CallAsync(rondpoint_33e7_switcheroo, aGlobal, aArgs, "rondpoint_33e7_switcheroo: "_ns, aError));
+     }
+-    case 86: { // sprites:sprites_accb_Sprite_new
++    case 86: { // sprites:sprites_a679_Sprite_new
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingObjectConverter<&kSpritesSpritePointerType>, ScaffoldingConverter<RustBuffer>>;
+-      return Some(CallHandler::CallAsync(sprites_accb_Sprite_new, aGlobal, aArgs, "sprites_accb_Sprite_new: "_ns, aError));
++      return Some(CallHandler::CallAsync(sprites_a679_Sprite_new, aGlobal, aArgs, "sprites_a679_Sprite_new: "_ns, aError));
+     }
+-    case 87: { // sprites:sprites_accb_Sprite_new_relative_to
++    case 87: { // sprites:sprites_a679_Sprite_new_relative_to
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingObjectConverter<&kSpritesSpritePointerType>, ScaffoldingConverter<RustBuffer>, ScaffoldingConverter<RustBuffer>>;
+-      return Some(CallHandler::CallAsync(sprites_accb_Sprite_new_relative_to, aGlobal, aArgs, "sprites_accb_Sprite_new_relative_to: "_ns, aError));
++      return Some(CallHandler::CallAsync(sprites_a679_Sprite_new_relative_to, aGlobal, aArgs, "sprites_a679_Sprite_new_relative_to: "_ns, aError));
+     }
+-    case 88: { // sprites:sprites_accb_Sprite_get_position
++    case 88: { // sprites:sprites_a679_Sprite_get_position
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kSpritesSpritePointerType>>;
+-      return Some(CallHandler::CallAsync(sprites_accb_Sprite_get_position, aGlobal, aArgs, "sprites_accb_Sprite_get_position: "_ns, aError));
++      return Some(CallHandler::CallAsync(sprites_a679_Sprite_get_position, aGlobal, aArgs, "sprites_a679_Sprite_get_position: "_ns, aError));
+     }
+-    case 89: { // sprites:sprites_accb_Sprite_move_to
++    case 89: { // sprites:sprites_a679_Sprite_move_to
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<void>, ScaffoldingObjectConverter<&kSpritesSpritePointerType>, ScaffoldingConverter<RustBuffer>>;
+-      return Some(CallHandler::CallAsync(sprites_accb_Sprite_move_to, aGlobal, aArgs, "sprites_accb_Sprite_move_to: "_ns, aError));
++      return Some(CallHandler::CallAsync(sprites_a679_Sprite_move_to, aGlobal, aArgs, "sprites_a679_Sprite_move_to: "_ns, aError));
+     }
+-    case 90: { // sprites:sprites_accb_Sprite_move_by
++    case 90: { // sprites:sprites_a679_Sprite_move_by
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<void>, ScaffoldingObjectConverter<&kSpritesSpritePointerType>, ScaffoldingConverter<RustBuffer>>;
+-      return Some(CallHandler::CallAsync(sprites_accb_Sprite_move_by, aGlobal, aArgs, "sprites_accb_Sprite_move_by: "_ns, aError));
++      return Some(CallHandler::CallAsync(sprites_a679_Sprite_move_by, aGlobal, aArgs, "sprites_a679_Sprite_move_by: "_ns, aError));
+     }
+-    case 91: { // sprites:sprites_accb_translate
++    case 91: { // sprites:sprites_a679_translate
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingConverter<RustBuffer>, ScaffoldingConverter<RustBuffer>>;
+-      return Some(CallHandler::CallAsync(sprites_accb_translate, aGlobal, aArgs, "sprites_accb_translate: "_ns, aError));
++      return Some(CallHandler::CallAsync(sprites_a679_translate, aGlobal, aArgs, "sprites_a679_translate: "_ns, aError));
+     }
+-    case 92: { // todolist:todolist_aa33_TodoList_new
++    case 92: { // todolist:todolist_cd5b_TodoList_new
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingObjectConverter<&kTodolistTodoListPointerType>>;
+-      return Some(CallHandler::CallAsync(todolist_aa33_TodoList_new, aGlobal, aArgs, "todolist_aa33_TodoList_new: "_ns, aError));
++      return Some(CallHandler::CallAsync(todolist_cd5b_TodoList_new, aGlobal, aArgs, "todolist_cd5b_TodoList_new: "_ns, aError));
+     }
+-    case 93: { // todolist:todolist_aa33_TodoList_add_item
++    case 93: { // todolist:todolist_cd5b_TodoList_add_item
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<void>, ScaffoldingObjectConverter<&kTodolistTodoListPointerType>, ScaffoldingConverter<RustBuffer>>;
+-      return Some(CallHandler::CallAsync(todolist_aa33_TodoList_add_item, aGlobal, aArgs, "todolist_aa33_TodoList_add_item: "_ns, aError));
++      return Some(CallHandler::CallAsync(todolist_cd5b_TodoList_add_item, aGlobal, aArgs, "todolist_cd5b_TodoList_add_item: "_ns, aError));
+     }
+-    case 94: { // todolist:todolist_aa33_TodoList_add_entry
++    case 94: { // todolist:todolist_cd5b_TodoList_add_entry
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<void>, ScaffoldingObjectConverter<&kTodolistTodoListPointerType>, ScaffoldingConverter<RustBuffer>>;
+-      return Some(CallHandler::CallAsync(todolist_aa33_TodoList_add_entry, aGlobal, aArgs, "todolist_aa33_TodoList_add_entry: "_ns, aError));
++      return Some(CallHandler::CallAsync(todolist_cd5b_TodoList_add_entry, aGlobal, aArgs, "todolist_cd5b_TodoList_add_entry: "_ns, aError));
+     }
+-    case 95: { // todolist:todolist_aa33_TodoList_get_entries
++    case 95: { // todolist:todolist_cd5b_TodoList_get_entries
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kTodolistTodoListPointerType>>;
+-      return Some(CallHandler::CallAsync(todolist_aa33_TodoList_get_entries, aGlobal, aArgs, "todolist_aa33_TodoList_get_entries: "_ns, aError));
++      return Some(CallHandler::CallAsync(todolist_cd5b_TodoList_get_entries, aGlobal, aArgs, "todolist_cd5b_TodoList_get_entries: "_ns, aError));
+     }
+-    case 96: { // todolist:todolist_aa33_TodoList_get_items
++    case 96: { // todolist:todolist_cd5b_TodoList_get_items
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kTodolistTodoListPointerType>>;
+-      return Some(CallHandler::CallAsync(todolist_aa33_TodoList_get_items, aGlobal, aArgs, "todolist_aa33_TodoList_get_items: "_ns, aError));
++      return Some(CallHandler::CallAsync(todolist_cd5b_TodoList_get_items, aGlobal, aArgs, "todolist_cd5b_TodoList_get_items: "_ns, aError));
+     }
+-    case 97: { // todolist:todolist_aa33_TodoList_add_entries
++    case 97: { // todolist:todolist_cd5b_TodoList_add_entries
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<void>, ScaffoldingObjectConverter<&kTodolistTodoListPointerType>, ScaffoldingConverter<RustBuffer>>;
+-      return Some(CallHandler::CallAsync(todolist_aa33_TodoList_add_entries, aGlobal, aArgs, "todolist_aa33_TodoList_add_entries: "_ns, aError));
++      return Some(CallHandler::CallAsync(todolist_cd5b_TodoList_add_entries, aGlobal, aArgs, "todolist_cd5b_TodoList_add_entries: "_ns, aError));
+     }
+-    case 98: { // todolist:todolist_aa33_TodoList_add_items
++    case 98: { // todolist:todolist_cd5b_TodoList_add_items
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<void>, ScaffoldingObjectConverter<&kTodolistTodoListPointerType>, ScaffoldingConverter<RustBuffer>>;
+-      return Some(CallHandler::CallAsync(todolist_aa33_TodoList_add_items, aGlobal, aArgs, "todolist_aa33_TodoList_add_items: "_ns, aError));
++      return Some(CallHandler::CallAsync(todolist_cd5b_TodoList_add_items, aGlobal, aArgs, "todolist_cd5b_TodoList_add_items: "_ns, aError));
+     }
+-    case 99: { // todolist:todolist_aa33_TodoList_get_last_entry
++    case 99: { // todolist:todolist_cd5b_TodoList_get_last_entry
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kTodolistTodoListPointerType>>;
+-      return Some(CallHandler::CallAsync(todolist_aa33_TodoList_get_last_entry, aGlobal, aArgs, "todolist_aa33_TodoList_get_last_entry: "_ns, aError));
++      return Some(CallHandler::CallAsync(todolist_cd5b_TodoList_get_last_entry, aGlobal, aArgs, "todolist_cd5b_TodoList_get_last_entry: "_ns, aError));
+     }
+-    case 100: { // todolist:todolist_aa33_TodoList_get_last
++    case 100: { // todolist:todolist_cd5b_TodoList_get_last
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kTodolistTodoListPointerType>>;
+-      return Some(CallHandler::CallAsync(todolist_aa33_TodoList_get_last, aGlobal, aArgs, "todolist_aa33_TodoList_get_last: "_ns, aError));
++      return Some(CallHandler::CallAsync(todolist_cd5b_TodoList_get_last, aGlobal, aArgs, "todolist_cd5b_TodoList_get_last: "_ns, aError));
+     }
+-    case 101: { // todolist:todolist_aa33_TodoList_get_first
++    case 101: { // todolist:todolist_cd5b_TodoList_get_first
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kTodolistTodoListPointerType>>;
+-      return Some(CallHandler::CallAsync(todolist_aa33_TodoList_get_first, aGlobal, aArgs, "todolist_aa33_TodoList_get_first: "_ns, aError));
++      return Some(CallHandler::CallAsync(todolist_cd5b_TodoList_get_first, aGlobal, aArgs, "todolist_cd5b_TodoList_get_first: "_ns, aError));
+     }
+-    case 102: { // todolist:todolist_aa33_TodoList_clear_item
++    case 102: { // todolist:todolist_cd5b_TodoList_clear_item
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<void>, ScaffoldingObjectConverter<&kTodolistTodoListPointerType>, ScaffoldingConverter<RustBuffer>>;
+-      return Some(CallHandler::CallAsync(todolist_aa33_TodoList_clear_item, aGlobal, aArgs, "todolist_aa33_TodoList_clear_item: "_ns, aError));
++      return Some(CallHandler::CallAsync(todolist_cd5b_TodoList_clear_item, aGlobal, aArgs, "todolist_cd5b_TodoList_clear_item: "_ns, aError));
+     }
+-    case 103: { // todolist:todolist_aa33_TodoList_make_default
++    case 103: { // todolist:todolist_cd5b_TodoList_make_default
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<void>, ScaffoldingObjectConverter<&kTodolistTodoListPointerType>>;
+-      return Some(CallHandler::CallAsync(todolist_aa33_TodoList_make_default, aGlobal, aArgs, "todolist_aa33_TodoList_make_default: "_ns, aError));
++      return Some(CallHandler::CallAsync(todolist_cd5b_TodoList_make_default, aGlobal, aArgs, "todolist_cd5b_TodoList_make_default: "_ns, aError));
+     }
+-    case 104: { // todolist:todolist_aa33_get_default_list
++    case 104: { // todolist:todolist_cd5b_get_default_list
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>>;
+-      return Some(CallHandler::CallAsync(todolist_aa33_get_default_list, aGlobal, aArgs, "todolist_aa33_get_default_list: "_ns, aError));
++      return Some(CallHandler::CallAsync(todolist_cd5b_get_default_list, aGlobal, aArgs, "todolist_cd5b_get_default_list: "_ns, aError));
+     }
+-    case 105: { // todolist:todolist_aa33_set_default_list
++    case 105: { // todolist:todolist_cd5b_set_default_list
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<void>, ScaffoldingObjectConverter<&kTodolistTodoListPointerType>>;
+-      return Some(CallHandler::CallAsync(todolist_aa33_set_default_list, aGlobal, aArgs, "todolist_aa33_set_default_list: "_ns, aError));
++      return Some(CallHandler::CallAsync(todolist_cd5b_set_default_list, aGlobal, aArgs, "todolist_cd5b_set_default_list: "_ns, aError));
+     }
+-    case 106: { // todolist:todolist_aa33_create_entry_with
++    case 106: { // todolist:todolist_cd5b_create_entry_with
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingConverter<RustBuffer>>;
+-      return Some(CallHandler::CallAsync(todolist_aa33_create_entry_with, aGlobal, aArgs, "todolist_aa33_create_entry_with: "_ns, aError));
++      return Some(CallHandler::CallAsync(todolist_cd5b_create_entry_with, aGlobal, aArgs, "todolist_cd5b_create_entry_with: "_ns, aError));
+     }
+-    case 107: { // custom_types:custom_types_8ecd_get_custom_types_demo
++    case 107: { // custom_types:custom_types_41fc_get_custom_types_demo
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingConverter<RustBuffer>>;
+-      return Some(CallHandler::CallAsync(custom_types_8ecd_get_custom_types_demo, aGlobal, aArgs, "custom_types_8ecd_get_custom_types_demo: "_ns, aError));
++      return Some(CallHandler::CallAsync(custom_types_41fc_get_custom_types_demo, aGlobal, aArgs, "custom_types_41fc_get_custom_types_demo: "_ns, aError));
+     }
+-    case 108: { // external_types:external_types_54cc_gradient
++    case 108: { // external_types:external_types_4cd4_gradient
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<double>, ScaffoldingConverter<RustBuffer>>;
+-      return Some(CallHandler::CallAsync(external_types_54cc_gradient, aGlobal, aArgs, "external_types_54cc_gradient: "_ns, aError));
++      return Some(CallHandler::CallAsync(external_types_4cd4_gradient, aGlobal, aArgs, "external_types_4cd4_gradient: "_ns, aError));
+     }
+   }
+   return Nothing();
+@@ -501,449 +501,449 @@
+ 
+ bool UniFFIFixturesCallSync(const GlobalObject& aGlobal, uint64_t aId, const Sequence<ScaffoldingType>& aArgs, RootedDictionary<UniFFIScaffoldingCallResult>& aReturnValue, ErrorResult& aError) {
+   switch (aId) {
+-    case 20: { // geometry:geometry_1cce_gradient
++    case 20: { // geometry:geometry_deb7_gradient
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<double>, ScaffoldingConverter<RustBuffer>>;
+-      CallHandler::CallSync(geometry_1cce_gradient, aGlobal, aArgs, aReturnValue, "geometry_1cce_gradient: "_ns, aError);
++      CallHandler::CallSync(geometry_deb7_gradient, aGlobal, aArgs, aReturnValue, "geometry_deb7_gradient: "_ns, aError);
+       return true;
+     }
+-    case 21: { // geometry:geometry_1cce_intersection
++    case 21: { // geometry:geometry_deb7_intersection
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingConverter<RustBuffer>, ScaffoldingConverter<RustBuffer>>;
+-      CallHandler::CallSync(geometry_1cce_intersection, aGlobal, aArgs, aReturnValue, "geometry_1cce_intersection: "_ns, aError);
++      CallHandler::CallSync(geometry_deb7_intersection, aGlobal, aArgs, aReturnValue, "geometry_deb7_intersection: "_ns, aError);
+       return true;
+     }
+-    case 22: { // arithmetic:arithmetic_906c_add
++    case 22: { // arithmetic:arithmetic_be49_add
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<uint64_t>, ScaffoldingConverter<uint64_t>, ScaffoldingConverter<uint64_t>>;
+-      CallHandler::CallSync(arithmetic_906c_add, aGlobal, aArgs, aReturnValue, "arithmetic_906c_add: "_ns, aError);
++      CallHandler::CallSync(arithmetic_be49_add, aGlobal, aArgs, aReturnValue, "arithmetic_be49_add: "_ns, aError);
+       return true;
+     }
+-    case 23: { // arithmetic:arithmetic_906c_sub
++    case 23: { // arithmetic:arithmetic_be49_sub
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<uint64_t>, ScaffoldingConverter<uint64_t>, ScaffoldingConverter<uint64_t>>;
+-      CallHandler::CallSync(arithmetic_906c_sub, aGlobal, aArgs, aReturnValue, "arithmetic_906c_sub: "_ns, aError);
++      CallHandler::CallSync(arithmetic_be49_sub, aGlobal, aArgs, aReturnValue, "arithmetic_be49_sub: "_ns, aError);
+       return true;
+     }
+-    case 24: { // arithmetic:arithmetic_906c_div
++    case 24: { // arithmetic:arithmetic_be49_div
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<uint64_t>, ScaffoldingConverter<uint64_t>, ScaffoldingConverter<uint64_t>>;
+-      CallHandler::CallSync(arithmetic_906c_div, aGlobal, aArgs, aReturnValue, "arithmetic_906c_div: "_ns, aError);
++      CallHandler::CallSync(arithmetic_be49_div, aGlobal, aArgs, aReturnValue, "arithmetic_be49_div: "_ns, aError);
+       return true;
+     }
+-    case 25: { // arithmetic:arithmetic_906c_equal
++    case 25: { // arithmetic:arithmetic_be49_equal
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<int8_t>, ScaffoldingConverter<uint64_t>, ScaffoldingConverter<uint64_t>>;
+-      CallHandler::CallSync(arithmetic_906c_equal, aGlobal, aArgs, aReturnValue, "arithmetic_906c_equal: "_ns, aError);
++      CallHandler::CallSync(arithmetic_be49_equal, aGlobal, aArgs, aReturnValue, "arithmetic_be49_equal: "_ns, aError);
+       return true;
+     }
+-    case 26: { // rondpoint:rondpoint_c6ef_Retourneur_new
++    case 26: { // rondpoint:rondpoint_33e7_Retourneur_new
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>>;
+-      CallHandler::CallSync(rondpoint_c6ef_Retourneur_new, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Retourneur_new: "_ns, aError);
++      CallHandler::CallSync(rondpoint_33e7_Retourneur_new, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Retourneur_new: "_ns, aError);
+       return true;
+     }
+-    case 27: { // rondpoint:rondpoint_c6ef_Retourneur_identique_i8
++    case 27: { // rondpoint:rondpoint_33e7_Retourneur_identique_i8
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<int8_t>, ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>, ScaffoldingConverter<int8_t>>;
+-      CallHandler::CallSync(rondpoint_c6ef_Retourneur_identique_i8, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Retourneur_identique_i8: "_ns, aError);
++      CallHandler::CallSync(rondpoint_33e7_Retourneur_identique_i8, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Retourneur_identique_i8: "_ns, aError);
+       return true;
+     }
+-    case 28: { // rondpoint:rondpoint_c6ef_Retourneur_identique_u8
++    case 28: { // rondpoint:rondpoint_33e7_Retourneur_identique_u8
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<uint8_t>, ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>, ScaffoldingConverter<uint8_t>>;
+-      CallHandler::CallSync(rondpoint_c6ef_Retourneur_identique_u8, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Retourneur_identique_u8: "_ns, aError);
++      CallHandler::CallSync(rondpoint_33e7_Retourneur_identique_u8, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Retourneur_identique_u8: "_ns, aError);
+       return true;
+     }
+-    case 29: { // rondpoint:rondpoint_c6ef_Retourneur_identique_i16
++    case 29: { // rondpoint:rondpoint_33e7_Retourneur_identique_i16
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<int16_t>, ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>, ScaffoldingConverter<int16_t>>;
+-      CallHandler::CallSync(rondpoint_c6ef_Retourneur_identique_i16, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Retourneur_identique_i16: "_ns, aError);
++      CallHandler::CallSync(rondpoint_33e7_Retourneur_identique_i16, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Retourneur_identique_i16: "_ns, aError);
+       return true;
+     }
+-    case 30: { // rondpoint:rondpoint_c6ef_Retourneur_identique_u16
++    case 30: { // rondpoint:rondpoint_33e7_Retourneur_identique_u16
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<uint16_t>, ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>, ScaffoldingConverter<uint16_t>>;
+-      CallHandler::CallSync(rondpoint_c6ef_Retourneur_identique_u16, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Retourneur_identique_u16: "_ns, aError);
++      CallHandler::CallSync(rondpoint_33e7_Retourneur_identique_u16, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Retourneur_identique_u16: "_ns, aError);
+       return true;
+     }
+-    case 31: { // rondpoint:rondpoint_c6ef_Retourneur_identique_i32
++    case 31: { // rondpoint:rondpoint_33e7_Retourneur_identique_i32
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<int32_t>, ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>, ScaffoldingConverter<int32_t>>;
+-      CallHandler::CallSync(rondpoint_c6ef_Retourneur_identique_i32, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Retourneur_identique_i32: "_ns, aError);
++      CallHandler::CallSync(rondpoint_33e7_Retourneur_identique_i32, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Retourneur_identique_i32: "_ns, aError);
+       return true;
+     }
+-    case 32: { // rondpoint:rondpoint_c6ef_Retourneur_identique_u32
++    case 32: { // rondpoint:rondpoint_33e7_Retourneur_identique_u32
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<uint32_t>, ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>, ScaffoldingConverter<uint32_t>>;
+-      CallHandler::CallSync(rondpoint_c6ef_Retourneur_identique_u32, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Retourneur_identique_u32: "_ns, aError);
++      CallHandler::CallSync(rondpoint_33e7_Retourneur_identique_u32, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Retourneur_identique_u32: "_ns, aError);
+       return true;
+     }
+-    case 33: { // rondpoint:rondpoint_c6ef_Retourneur_identique_i64
++    case 33: { // rondpoint:rondpoint_33e7_Retourneur_identique_i64
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<int64_t>, ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>, ScaffoldingConverter<int64_t>>;
+-      CallHandler::CallSync(rondpoint_c6ef_Retourneur_identique_i64, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Retourneur_identique_i64: "_ns, aError);
++      CallHandler::CallSync(rondpoint_33e7_Retourneur_identique_i64, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Retourneur_identique_i64: "_ns, aError);
+       return true;
+     }
+-    case 34: { // rondpoint:rondpoint_c6ef_Retourneur_identique_u64
++    case 34: { // rondpoint:rondpoint_33e7_Retourneur_identique_u64
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<uint64_t>, ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>, ScaffoldingConverter<uint64_t>>;
+-      CallHandler::CallSync(rondpoint_c6ef_Retourneur_identique_u64, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Retourneur_identique_u64: "_ns, aError);
++      CallHandler::CallSync(rondpoint_33e7_Retourneur_identique_u64, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Retourneur_identique_u64: "_ns, aError);
+       return true;
+     }
+-    case 35: { // rondpoint:rondpoint_c6ef_Retourneur_identique_float
++    case 35: { // rondpoint:rondpoint_33e7_Retourneur_identique_float
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<float>, ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>, ScaffoldingConverter<float>>;
+-      CallHandler::CallSync(rondpoint_c6ef_Retourneur_identique_float, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Retourneur_identique_float: "_ns, aError);
++      CallHandler::CallSync(rondpoint_33e7_Retourneur_identique_float, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Retourneur_identique_float: "_ns, aError);
+       return true;
+     }
+-    case 36: { // rondpoint:rondpoint_c6ef_Retourneur_identique_double
++    case 36: { // rondpoint:rondpoint_33e7_Retourneur_identique_double
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<double>, ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>, ScaffoldingConverter<double>>;
+-      CallHandler::CallSync(rondpoint_c6ef_Retourneur_identique_double, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Retourneur_identique_double: "_ns, aError);
++      CallHandler::CallSync(rondpoint_33e7_Retourneur_identique_double, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Retourneur_identique_double: "_ns, aError);
+       return true;
+     }
+-    case 37: { // rondpoint:rondpoint_c6ef_Retourneur_identique_boolean
++    case 37: { // rondpoint:rondpoint_33e7_Retourneur_identique_boolean
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<int8_t>, ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>, ScaffoldingConverter<int8_t>>;
+-      CallHandler::CallSync(rondpoint_c6ef_Retourneur_identique_boolean, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Retourneur_identique_boolean: "_ns, aError);
++      CallHandler::CallSync(rondpoint_33e7_Retourneur_identique_boolean, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Retourneur_identique_boolean: "_ns, aError);
+       return true;
+     }
+-    case 38: { // rondpoint:rondpoint_c6ef_Retourneur_identique_string
++    case 38: { // rondpoint:rondpoint_33e7_Retourneur_identique_string
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>, ScaffoldingConverter<RustBuffer>>;
+-      CallHandler::CallSync(rondpoint_c6ef_Retourneur_identique_string, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Retourneur_identique_string: "_ns, aError);
++      CallHandler::CallSync(rondpoint_33e7_Retourneur_identique_string, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Retourneur_identique_string: "_ns, aError);
+       return true;
+     }
+-    case 39: { // rondpoint:rondpoint_c6ef_Retourneur_identique_nombres_signes
++    case 39: { // rondpoint:rondpoint_33e7_Retourneur_identique_nombres_signes
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>, ScaffoldingConverter<RustBuffer>>;
+-      CallHandler::CallSync(rondpoint_c6ef_Retourneur_identique_nombres_signes, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Retourneur_identique_nombres_signes: "_ns, aError);
++      CallHandler::CallSync(rondpoint_33e7_Retourneur_identique_nombres_signes, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Retourneur_identique_nombres_signes: "_ns, aError);
+       return true;
+     }
+-    case 40: { // rondpoint:rondpoint_c6ef_Retourneur_identique_nombres
++    case 40: { // rondpoint:rondpoint_33e7_Retourneur_identique_nombres
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>, ScaffoldingConverter<RustBuffer>>;
+-      CallHandler::CallSync(rondpoint_c6ef_Retourneur_identique_nombres, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Retourneur_identique_nombres: "_ns, aError);
++      CallHandler::CallSync(rondpoint_33e7_Retourneur_identique_nombres, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Retourneur_identique_nombres: "_ns, aError);
+       return true;
+     }
+-    case 41: { // rondpoint:rondpoint_c6ef_Retourneur_identique_optionneur_dictionnaire
++    case 41: { // rondpoint:rondpoint_33e7_Retourneur_identique_optionneur_dictionnaire
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kRondpointRetourneurPointerType>, ScaffoldingConverter<RustBuffer>>;
+-      CallHandler::CallSync(rondpoint_c6ef_Retourneur_identique_optionneur_dictionnaire, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Retourneur_identique_optionneur_dictionnaire: "_ns, aError);
++      CallHandler::CallSync(rondpoint_33e7_Retourneur_identique_optionneur_dictionnaire, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Retourneur_identique_optionneur_dictionnaire: "_ns, aError);
+       return true;
+     }
+-    case 42: { // rondpoint:rondpoint_c6ef_Stringifier_new
++    case 42: { // rondpoint:rondpoint_33e7_Stringifier_new
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingObjectConverter<&kRondpointStringifierPointerType>>;
+-      CallHandler::CallSync(rondpoint_c6ef_Stringifier_new, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Stringifier_new: "_ns, aError);
++      CallHandler::CallSync(rondpoint_33e7_Stringifier_new, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Stringifier_new: "_ns, aError);
+       return true;
+     }
+-    case 43: { // rondpoint:rondpoint_c6ef_Stringifier_well_known_string
++    case 43: { // rondpoint:rondpoint_33e7_Stringifier_well_known_string
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kRondpointStringifierPointerType>, ScaffoldingConverter<RustBuffer>>;
+-      CallHandler::CallSync(rondpoint_c6ef_Stringifier_well_known_string, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Stringifier_well_known_string: "_ns, aError);
++      CallHandler::CallSync(rondpoint_33e7_Stringifier_well_known_string, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Stringifier_well_known_string: "_ns, aError);
+       return true;
+     }
+-    case 44: { // rondpoint:rondpoint_c6ef_Stringifier_to_string_i8
++    case 44: { // rondpoint:rondpoint_33e7_Stringifier_to_string_i8
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kRondpointStringifierPointerType>, ScaffoldingConverter<int8_t>>;
+-      CallHandler::CallSync(rondpoint_c6ef_Stringifier_to_string_i8, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Stringifier_to_string_i8: "_ns, aError);
++      CallHandler::CallSync(rondpoint_33e7_Stringifier_to_string_i8, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Stringifier_to_string_i8: "_ns, aError);
+       return true;
+     }
+-    case 45: { // rondpoint:rondpoint_c6ef_Stringifier_to_string_u8
++    case 45: { // rondpoint:rondpoint_33e7_Stringifier_to_string_u8
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kRondpointStringifierPointerType>, ScaffoldingConverter<uint8_t>>;
+-      CallHandler::CallSync(rondpoint_c6ef_Stringifier_to_string_u8, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Stringifier_to_string_u8: "_ns, aError);
++      CallHandler::CallSync(rondpoint_33e7_Stringifier_to_string_u8, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Stringifier_to_string_u8: "_ns, aError);
+       return true;
+     }
+-    case 46: { // rondpoint:rondpoint_c6ef_Stringifier_to_string_i16
++    case 46: { // rondpoint:rondpoint_33e7_Stringifier_to_string_i16
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kRondpointStringifierPointerType>, ScaffoldingConverter<int16_t>>;
+-      CallHandler::CallSync(rondpoint_c6ef_Stringifier_to_string_i16, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Stringifier_to_string_i16: "_ns, aError);
++      CallHandler::CallSync(rondpoint_33e7_Stringifier_to_string_i16, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Stringifier_to_string_i16: "_ns, aError);
+       return true;
+     }
+-    case 47: { // rondpoint:rondpoint_c6ef_Stringifier_to_string_u16
++    case 47: { // rondpoint:rondpoint_33e7_Stringifier_to_string_u16
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kRondpointStringifierPointerType>, ScaffoldingConverter<uint16_t>>;
+-      CallHandler::CallSync(rondpoint_c6ef_Stringifier_to_string_u16, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Stringifier_to_string_u16: "_ns, aError);
++      CallHandler::CallSync(rondpoint_33e7_Stringifier_to_string_u16, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Stringifier_to_string_u16: "_ns, aError);
+       return true;
+     }
+-    case 48: { // rondpoint:rondpoint_c6ef_Stringifier_to_string_i32
++    case 48: { // rondpoint:rondpoint_33e7_Stringifier_to_string_i32
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kRondpointStringifierPointerType>, ScaffoldingConverter<int32_t>>;
+-      CallHandler::CallSync(rondpoint_c6ef_Stringifier_to_string_i32, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Stringifier_to_string_i32: "_ns, aError);
++      CallHandler::CallSync(rondpoint_33e7_Stringifier_to_string_i32, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Stringifier_to_string_i32: "_ns, aError);
+       return true;
+     }
+-    case 49: { // rondpoint:rondpoint_c6ef_Stringifier_to_string_u32
++    case 49: { // rondpoint:rondpoint_33e7_Stringifier_to_string_u32
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kRondpointStringifierPointerType>, ScaffoldingConverter<uint32_t>>;
+-      CallHandler::CallSync(rondpoint_c6ef_Stringifier_to_string_u32, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Stringifier_to_string_u32: "_ns, aError);
++      CallHandler::CallSync(rondpoint_33e7_Stringifier_to_string_u32, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Stringifier_to_string_u32: "_ns, aError);
+       return true;
+     }
+-    case 50: { // rondpoint:rondpoint_c6ef_Stringifier_to_string_i64
++    case 50: { // rondpoint:rondpoint_33e7_Stringifier_to_string_i64
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kRondpointStringifierPointerType>, ScaffoldingConverter<int64_t>>;
+-      CallHandler::CallSync(rondpoint_c6ef_Stringifier_to_string_i64, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Stringifier_to_string_i64: "_ns, aError);
++      CallHandler::CallSync(rondpoint_33e7_Stringifier_to_string_i64, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Stringifier_to_string_i64: "_ns, aError);
+       return true;
+     }
+-    case 51: { // rondpoint:rondpoint_c6ef_Stringifier_to_string_u64
++    case 51: { // rondpoint:rondpoint_33e7_Stringifier_to_string_u64
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kRondpointStringifierPointerType>, ScaffoldingConverter<uint64_t>>;
+-      CallHandler::CallSync(rondpoint_c6ef_Stringifier_to_string_u64, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Stringifier_to_string_u64: "_ns, aError);
++      CallHandler::CallSync(rondpoint_33e7_Stringifier_to_string_u64, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Stringifier_to_string_u64: "_ns, aError);
+       return true;
+     }
+-    case 52: { // rondpoint:rondpoint_c6ef_Stringifier_to_string_float
++    case 52: { // rondpoint:rondpoint_33e7_Stringifier_to_string_float
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kRondpointStringifierPointerType>, ScaffoldingConverter<float>>;
+-      CallHandler::CallSync(rondpoint_c6ef_Stringifier_to_string_float, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Stringifier_to_string_float: "_ns, aError);
++      CallHandler::CallSync(rondpoint_33e7_Stringifier_to_string_float, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Stringifier_to_string_float: "_ns, aError);
+       return true;
+     }
+-    case 53: { // rondpoint:rondpoint_c6ef_Stringifier_to_string_double
++    case 53: { // rondpoint:rondpoint_33e7_Stringifier_to_string_double
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kRondpointStringifierPointerType>, ScaffoldingConverter<double>>;
+-      CallHandler::CallSync(rondpoint_c6ef_Stringifier_to_string_double, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Stringifier_to_string_double: "_ns, aError);
++      CallHandler::CallSync(rondpoint_33e7_Stringifier_to_string_double, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Stringifier_to_string_double: "_ns, aError);
+       return true;
+     }
+-    case 54: { // rondpoint:rondpoint_c6ef_Stringifier_to_string_boolean
++    case 54: { // rondpoint:rondpoint_33e7_Stringifier_to_string_boolean
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kRondpointStringifierPointerType>, ScaffoldingConverter<int8_t>>;
+-      CallHandler::CallSync(rondpoint_c6ef_Stringifier_to_string_boolean, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Stringifier_to_string_boolean: "_ns, aError);
++      CallHandler::CallSync(rondpoint_33e7_Stringifier_to_string_boolean, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Stringifier_to_string_boolean: "_ns, aError);
+       return true;
+     }
+-    case 55: { // rondpoint:rondpoint_c6ef_Optionneur_new
++    case 55: { // rondpoint:rondpoint_33e7_Optionneur_new
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>>;
+-      CallHandler::CallSync(rondpoint_c6ef_Optionneur_new, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Optionneur_new: "_ns, aError);
++      CallHandler::CallSync(rondpoint_33e7_Optionneur_new, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Optionneur_new: "_ns, aError);
+       return true;
+     }
+-    case 56: { // rondpoint:rondpoint_c6ef_Optionneur_sinon_boolean
++    case 56: { // rondpoint:rondpoint_33e7_Optionneur_sinon_boolean
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<int8_t>, ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>, ScaffoldingConverter<int8_t>>;
+-      CallHandler::CallSync(rondpoint_c6ef_Optionneur_sinon_boolean, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Optionneur_sinon_boolean: "_ns, aError);
++      CallHandler::CallSync(rondpoint_33e7_Optionneur_sinon_boolean, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Optionneur_sinon_boolean: "_ns, aError);
+       return true;
+     }
+-    case 57: { // rondpoint:rondpoint_c6ef_Optionneur_sinon_string
++    case 57: { // rondpoint:rondpoint_33e7_Optionneur_sinon_string
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>, ScaffoldingConverter<RustBuffer>>;
+-      CallHandler::CallSync(rondpoint_c6ef_Optionneur_sinon_string, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Optionneur_sinon_string: "_ns, aError);
++      CallHandler::CallSync(rondpoint_33e7_Optionneur_sinon_string, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Optionneur_sinon_string: "_ns, aError);
+       return true;
+     }
+-    case 58: { // rondpoint:rondpoint_c6ef_Optionneur_sinon_sequence
++    case 58: { // rondpoint:rondpoint_33e7_Optionneur_sinon_sequence
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>, ScaffoldingConverter<RustBuffer>>;
+-      CallHandler::CallSync(rondpoint_c6ef_Optionneur_sinon_sequence, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Optionneur_sinon_sequence: "_ns, aError);
++      CallHandler::CallSync(rondpoint_33e7_Optionneur_sinon_sequence, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Optionneur_sinon_sequence: "_ns, aError);
+       return true;
+     }
+-    case 59: { // rondpoint:rondpoint_c6ef_Optionneur_sinon_null
++    case 59: { // rondpoint:rondpoint_33e7_Optionneur_sinon_null
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>, ScaffoldingConverter<RustBuffer>>;
+-      CallHandler::CallSync(rondpoint_c6ef_Optionneur_sinon_null, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Optionneur_sinon_null: "_ns, aError);
++      CallHandler::CallSync(rondpoint_33e7_Optionneur_sinon_null, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Optionneur_sinon_null: "_ns, aError);
+       return true;
+     }
+-    case 60: { // rondpoint:rondpoint_c6ef_Optionneur_sinon_zero
++    case 60: { // rondpoint:rondpoint_33e7_Optionneur_sinon_zero
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>, ScaffoldingConverter<RustBuffer>>;
+-      CallHandler::CallSync(rondpoint_c6ef_Optionneur_sinon_zero, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Optionneur_sinon_zero: "_ns, aError);
++      CallHandler::CallSync(rondpoint_33e7_Optionneur_sinon_zero, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Optionneur_sinon_zero: "_ns, aError);
+       return true;
+     }
+-    case 61: { // rondpoint:rondpoint_c6ef_Optionneur_sinon_u8_dec
++    case 61: { // rondpoint:rondpoint_33e7_Optionneur_sinon_u8_dec
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<uint8_t>, ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>, ScaffoldingConverter<uint8_t>>;
+-      CallHandler::CallSync(rondpoint_c6ef_Optionneur_sinon_u8_dec, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Optionneur_sinon_u8_dec: "_ns, aError);
++      CallHandler::CallSync(rondpoint_33e7_Optionneur_sinon_u8_dec, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Optionneur_sinon_u8_dec: "_ns, aError);
+       return true;
+     }
+-    case 62: { // rondpoint:rondpoint_c6ef_Optionneur_sinon_i8_dec
++    case 62: { // rondpoint:rondpoint_33e7_Optionneur_sinon_i8_dec
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<int8_t>, ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>, ScaffoldingConverter<int8_t>>;
+-      CallHandler::CallSync(rondpoint_c6ef_Optionneur_sinon_i8_dec, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Optionneur_sinon_i8_dec: "_ns, aError);
++      CallHandler::CallSync(rondpoint_33e7_Optionneur_sinon_i8_dec, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Optionneur_sinon_i8_dec: "_ns, aError);
+       return true;
+     }
+-    case 63: { // rondpoint:rondpoint_c6ef_Optionneur_sinon_u16_dec
++    case 63: { // rondpoint:rondpoint_33e7_Optionneur_sinon_u16_dec
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<uint16_t>, ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>, ScaffoldingConverter<uint16_t>>;
+-      CallHandler::CallSync(rondpoint_c6ef_Optionneur_sinon_u16_dec, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Optionneur_sinon_u16_dec: "_ns, aError);
++      CallHandler::CallSync(rondpoint_33e7_Optionneur_sinon_u16_dec, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Optionneur_sinon_u16_dec: "_ns, aError);
+       return true;
+     }
+-    case 64: { // rondpoint:rondpoint_c6ef_Optionneur_sinon_i16_dec
++    case 64: { // rondpoint:rondpoint_33e7_Optionneur_sinon_i16_dec
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<int16_t>, ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>, ScaffoldingConverter<int16_t>>;
+-      CallHandler::CallSync(rondpoint_c6ef_Optionneur_sinon_i16_dec, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Optionneur_sinon_i16_dec: "_ns, aError);
++      CallHandler::CallSync(rondpoint_33e7_Optionneur_sinon_i16_dec, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Optionneur_sinon_i16_dec: "_ns, aError);
+       return true;
+     }
+-    case 65: { // rondpoint:rondpoint_c6ef_Optionneur_sinon_u32_dec
++    case 65: { // rondpoint:rondpoint_33e7_Optionneur_sinon_u32_dec
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<uint32_t>, ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>, ScaffoldingConverter<uint32_t>>;
+-      CallHandler::CallSync(rondpoint_c6ef_Optionneur_sinon_u32_dec, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Optionneur_sinon_u32_dec: "_ns, aError);
++      CallHandler::CallSync(rondpoint_33e7_Optionneur_sinon_u32_dec, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Optionneur_sinon_u32_dec: "_ns, aError);
+       return true;
+     }
+-    case 66: { // rondpoint:rondpoint_c6ef_Optionneur_sinon_i32_dec
++    case 66: { // rondpoint:rondpoint_33e7_Optionneur_sinon_i32_dec
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<int32_t>, ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>, ScaffoldingConverter<int32_t>>;
+-      CallHandler::CallSync(rondpoint_c6ef_Optionneur_sinon_i32_dec, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Optionneur_sinon_i32_dec: "_ns, aError);
++      CallHandler::CallSync(rondpoint_33e7_Optionneur_sinon_i32_dec, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Optionneur_sinon_i32_dec: "_ns, aError);
+       return true;
+     }
+-    case 67: { // rondpoint:rondpoint_c6ef_Optionneur_sinon_u64_dec
++    case 67: { // rondpoint:rondpoint_33e7_Optionneur_sinon_u64_dec
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<uint64_t>, ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>, ScaffoldingConverter<uint64_t>>;
+-      CallHandler::CallSync(rondpoint_c6ef_Optionneur_sinon_u64_dec, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Optionneur_sinon_u64_dec: "_ns, aError);
++      CallHandler::CallSync(rondpoint_33e7_Optionneur_sinon_u64_dec, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Optionneur_sinon_u64_dec: "_ns, aError);
+       return true;
+     }
+-    case 68: { // rondpoint:rondpoint_c6ef_Optionneur_sinon_i64_dec
++    case 68: { // rondpoint:rondpoint_33e7_Optionneur_sinon_i64_dec
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<int64_t>, ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>, ScaffoldingConverter<int64_t>>;
+-      CallHandler::CallSync(rondpoint_c6ef_Optionneur_sinon_i64_dec, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Optionneur_sinon_i64_dec: "_ns, aError);
++      CallHandler::CallSync(rondpoint_33e7_Optionneur_sinon_i64_dec, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Optionneur_sinon_i64_dec: "_ns, aError);
+       return true;
+     }
+-    case 69: { // rondpoint:rondpoint_c6ef_Optionneur_sinon_u8_hex
++    case 69: { // rondpoint:rondpoint_33e7_Optionneur_sinon_u8_hex
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<uint8_t>, ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>, ScaffoldingConverter<uint8_t>>;
+-      CallHandler::CallSync(rondpoint_c6ef_Optionneur_sinon_u8_hex, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Optionneur_sinon_u8_hex: "_ns, aError);
++      CallHandler::CallSync(rondpoint_33e7_Optionneur_sinon_u8_hex, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Optionneur_sinon_u8_hex: "_ns, aError);
+       return true;
+     }
+-    case 70: { // rondpoint:rondpoint_c6ef_Optionneur_sinon_i8_hex
++    case 70: { // rondpoint:rondpoint_33e7_Optionneur_sinon_i8_hex
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<int8_t>, ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>, ScaffoldingConverter<int8_t>>;
+-      CallHandler::CallSync(rondpoint_c6ef_Optionneur_sinon_i8_hex, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Optionneur_sinon_i8_hex: "_ns, aError);
++      CallHandler::CallSync(rondpoint_33e7_Optionneur_sinon_i8_hex, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Optionneur_sinon_i8_hex: "_ns, aError);
+       return true;
+     }
+-    case 71: { // rondpoint:rondpoint_c6ef_Optionneur_sinon_u16_hex
++    case 71: { // rondpoint:rondpoint_33e7_Optionneur_sinon_u16_hex
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<uint16_t>, ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>, ScaffoldingConverter<uint16_t>>;
+-      CallHandler::CallSync(rondpoint_c6ef_Optionneur_sinon_u16_hex, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Optionneur_sinon_u16_hex: "_ns, aError);
++      CallHandler::CallSync(rondpoint_33e7_Optionneur_sinon_u16_hex, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Optionneur_sinon_u16_hex: "_ns, aError);
+       return true;
+     }
+-    case 72: { // rondpoint:rondpoint_c6ef_Optionneur_sinon_i16_hex
++    case 72: { // rondpoint:rondpoint_33e7_Optionneur_sinon_i16_hex
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<int16_t>, ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>, ScaffoldingConverter<int16_t>>;
+-      CallHandler::CallSync(rondpoint_c6ef_Optionneur_sinon_i16_hex, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Optionneur_sinon_i16_hex: "_ns, aError);
++      CallHandler::CallSync(rondpoint_33e7_Optionneur_sinon_i16_hex, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Optionneur_sinon_i16_hex: "_ns, aError);
+       return true;
+     }
+-    case 73: { // rondpoint:rondpoint_c6ef_Optionneur_sinon_u32_hex
++    case 73: { // rondpoint:rondpoint_33e7_Optionneur_sinon_u32_hex
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<uint32_t>, ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>, ScaffoldingConverter<uint32_t>>;
+-      CallHandler::CallSync(rondpoint_c6ef_Optionneur_sinon_u32_hex, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Optionneur_sinon_u32_hex: "_ns, aError);
++      CallHandler::CallSync(rondpoint_33e7_Optionneur_sinon_u32_hex, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Optionneur_sinon_u32_hex: "_ns, aError);
+       return true;
+     }
+-    case 74: { // rondpoint:rondpoint_c6ef_Optionneur_sinon_i32_hex
++    case 74: { // rondpoint:rondpoint_33e7_Optionneur_sinon_i32_hex
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<int32_t>, ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>, ScaffoldingConverter<int32_t>>;
+-      CallHandler::CallSync(rondpoint_c6ef_Optionneur_sinon_i32_hex, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Optionneur_sinon_i32_hex: "_ns, aError);
++      CallHandler::CallSync(rondpoint_33e7_Optionneur_sinon_i32_hex, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Optionneur_sinon_i32_hex: "_ns, aError);
+       return true;
+     }
+-    case 75: { // rondpoint:rondpoint_c6ef_Optionneur_sinon_u64_hex
++    case 75: { // rondpoint:rondpoint_33e7_Optionneur_sinon_u64_hex
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<uint64_t>, ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>, ScaffoldingConverter<uint64_t>>;
+-      CallHandler::CallSync(rondpoint_c6ef_Optionneur_sinon_u64_hex, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Optionneur_sinon_u64_hex: "_ns, aError);
++      CallHandler::CallSync(rondpoint_33e7_Optionneur_sinon_u64_hex, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Optionneur_sinon_u64_hex: "_ns, aError);
+       return true;
+     }
+-    case 76: { // rondpoint:rondpoint_c6ef_Optionneur_sinon_i64_hex
++    case 76: { // rondpoint:rondpoint_33e7_Optionneur_sinon_i64_hex
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<int64_t>, ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>, ScaffoldingConverter<int64_t>>;
+-      CallHandler::CallSync(rondpoint_c6ef_Optionneur_sinon_i64_hex, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Optionneur_sinon_i64_hex: "_ns, aError);
++      CallHandler::CallSync(rondpoint_33e7_Optionneur_sinon_i64_hex, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Optionneur_sinon_i64_hex: "_ns, aError);
+       return true;
+     }
+-    case 77: { // rondpoint:rondpoint_c6ef_Optionneur_sinon_u32_oct
++    case 77: { // rondpoint:rondpoint_33e7_Optionneur_sinon_u32_oct
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<uint32_t>, ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>, ScaffoldingConverter<uint32_t>>;
+-      CallHandler::CallSync(rondpoint_c6ef_Optionneur_sinon_u32_oct, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Optionneur_sinon_u32_oct: "_ns, aError);
++      CallHandler::CallSync(rondpoint_33e7_Optionneur_sinon_u32_oct, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Optionneur_sinon_u32_oct: "_ns, aError);
+       return true;
+     }
+-    case 78: { // rondpoint:rondpoint_c6ef_Optionneur_sinon_f32
++    case 78: { // rondpoint:rondpoint_33e7_Optionneur_sinon_f32
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<float>, ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>, ScaffoldingConverter<float>>;
+-      CallHandler::CallSync(rondpoint_c6ef_Optionneur_sinon_f32, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Optionneur_sinon_f32: "_ns, aError);
++      CallHandler::CallSync(rondpoint_33e7_Optionneur_sinon_f32, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Optionneur_sinon_f32: "_ns, aError);
+       return true;
+     }
+-    case 79: { // rondpoint:rondpoint_c6ef_Optionneur_sinon_f64
++    case 79: { // rondpoint:rondpoint_33e7_Optionneur_sinon_f64
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<double>, ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>, ScaffoldingConverter<double>>;
+-      CallHandler::CallSync(rondpoint_c6ef_Optionneur_sinon_f64, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Optionneur_sinon_f64: "_ns, aError);
++      CallHandler::CallSync(rondpoint_33e7_Optionneur_sinon_f64, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Optionneur_sinon_f64: "_ns, aError);
+       return true;
+     }
+-    case 80: { // rondpoint:rondpoint_c6ef_Optionneur_sinon_enum
++    case 80: { // rondpoint:rondpoint_33e7_Optionneur_sinon_enum
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kRondpointOptionneurPointerType>, ScaffoldingConverter<RustBuffer>>;
+-      CallHandler::CallSync(rondpoint_c6ef_Optionneur_sinon_enum, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_Optionneur_sinon_enum: "_ns, aError);
++      CallHandler::CallSync(rondpoint_33e7_Optionneur_sinon_enum, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_Optionneur_sinon_enum: "_ns, aError);
+       return true;
+     }
+-    case 81: { // rondpoint:rondpoint_c6ef_copie_dictionnaire
++    case 81: { // rondpoint:rondpoint_33e7_copie_dictionnaire
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingConverter<RustBuffer>>;
+-      CallHandler::CallSync(rondpoint_c6ef_copie_dictionnaire, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_copie_dictionnaire: "_ns, aError);
++      CallHandler::CallSync(rondpoint_33e7_copie_dictionnaire, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_copie_dictionnaire: "_ns, aError);
+       return true;
+     }
+-    case 82: { // rondpoint:rondpoint_c6ef_copie_enumeration
++    case 82: { // rondpoint:rondpoint_33e7_copie_enumeration
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingConverter<RustBuffer>>;
+-      CallHandler::CallSync(rondpoint_c6ef_copie_enumeration, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_copie_enumeration: "_ns, aError);
++      CallHandler::CallSync(rondpoint_33e7_copie_enumeration, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_copie_enumeration: "_ns, aError);
+       return true;
+     }
+-    case 83: { // rondpoint:rondpoint_c6ef_copie_enumerations
++    case 83: { // rondpoint:rondpoint_33e7_copie_enumerations
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingConverter<RustBuffer>>;
+-      CallHandler::CallSync(rondpoint_c6ef_copie_enumerations, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_copie_enumerations: "_ns, aError);
++      CallHandler::CallSync(rondpoint_33e7_copie_enumerations, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_copie_enumerations: "_ns, aError);
+       return true;
+     }
+-    case 84: { // rondpoint:rondpoint_c6ef_copie_carte
++    case 84: { // rondpoint:rondpoint_33e7_copie_carte
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingConverter<RustBuffer>>;
+-      CallHandler::CallSync(rondpoint_c6ef_copie_carte, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_copie_carte: "_ns, aError);
++      CallHandler::CallSync(rondpoint_33e7_copie_carte, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_copie_carte: "_ns, aError);
+       return true;
+     }
+-    case 85: { // rondpoint:rondpoint_c6ef_switcheroo
++    case 85: { // rondpoint:rondpoint_33e7_switcheroo
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<int8_t>, ScaffoldingConverter<int8_t>>;
+-      CallHandler::CallSync(rondpoint_c6ef_switcheroo, aGlobal, aArgs, aReturnValue, "rondpoint_c6ef_switcheroo: "_ns, aError);
++      CallHandler::CallSync(rondpoint_33e7_switcheroo, aGlobal, aArgs, aReturnValue, "rondpoint_33e7_switcheroo: "_ns, aError);
+       return true;
+     }
+-    case 86: { // sprites:sprites_accb_Sprite_new
++    case 86: { // sprites:sprites_a679_Sprite_new
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingObjectConverter<&kSpritesSpritePointerType>, ScaffoldingConverter<RustBuffer>>;
+-      CallHandler::CallSync(sprites_accb_Sprite_new, aGlobal, aArgs, aReturnValue, "sprites_accb_Sprite_new: "_ns, aError);
++      CallHandler::CallSync(sprites_a679_Sprite_new, aGlobal, aArgs, aReturnValue, "sprites_a679_Sprite_new: "_ns, aError);
+       return true;
+     }
+-    case 87: { // sprites:sprites_accb_Sprite_new_relative_to
++    case 87: { // sprites:sprites_a679_Sprite_new_relative_to
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingObjectConverter<&kSpritesSpritePointerType>, ScaffoldingConverter<RustBuffer>, ScaffoldingConverter<RustBuffer>>;
+-      CallHandler::CallSync(sprites_accb_Sprite_new_relative_to, aGlobal, aArgs, aReturnValue, "sprites_accb_Sprite_new_relative_to: "_ns, aError);
++      CallHandler::CallSync(sprites_a679_Sprite_new_relative_to, aGlobal, aArgs, aReturnValue, "sprites_a679_Sprite_new_relative_to: "_ns, aError);
+       return true;
+     }
+-    case 88: { // sprites:sprites_accb_Sprite_get_position
++    case 88: { // sprites:sprites_a679_Sprite_get_position
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kSpritesSpritePointerType>>;
+-      CallHandler::CallSync(sprites_accb_Sprite_get_position, aGlobal, aArgs, aReturnValue, "sprites_accb_Sprite_get_position: "_ns, aError);
++      CallHandler::CallSync(sprites_a679_Sprite_get_position, aGlobal, aArgs, aReturnValue, "sprites_a679_Sprite_get_position: "_ns, aError);
+       return true;
+     }
+-    case 89: { // sprites:sprites_accb_Sprite_move_to
++    case 89: { // sprites:sprites_a679_Sprite_move_to
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<void>, ScaffoldingObjectConverter<&kSpritesSpritePointerType>, ScaffoldingConverter<RustBuffer>>;
+-      CallHandler::CallSync(sprites_accb_Sprite_move_to, aGlobal, aArgs, aReturnValue, "sprites_accb_Sprite_move_to: "_ns, aError);
++      CallHandler::CallSync(sprites_a679_Sprite_move_to, aGlobal, aArgs, aReturnValue, "sprites_a679_Sprite_move_to: "_ns, aError);
+       return true;
+     }
+-    case 90: { // sprites:sprites_accb_Sprite_move_by
++    case 90: { // sprites:sprites_a679_Sprite_move_by
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<void>, ScaffoldingObjectConverter<&kSpritesSpritePointerType>, ScaffoldingConverter<RustBuffer>>;
+-      CallHandler::CallSync(sprites_accb_Sprite_move_by, aGlobal, aArgs, aReturnValue, "sprites_accb_Sprite_move_by: "_ns, aError);
++      CallHandler::CallSync(sprites_a679_Sprite_move_by, aGlobal, aArgs, aReturnValue, "sprites_a679_Sprite_move_by: "_ns, aError);
+       return true;
+     }
+-    case 91: { // sprites:sprites_accb_translate
++    case 91: { // sprites:sprites_a679_translate
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingConverter<RustBuffer>, ScaffoldingConverter<RustBuffer>>;
+-      CallHandler::CallSync(sprites_accb_translate, aGlobal, aArgs, aReturnValue, "sprites_accb_translate: "_ns, aError);
++      CallHandler::CallSync(sprites_a679_translate, aGlobal, aArgs, aReturnValue, "sprites_a679_translate: "_ns, aError);
+       return true;
+     }
+-    case 92: { // todolist:todolist_aa33_TodoList_new
++    case 92: { // todolist:todolist_cd5b_TodoList_new
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingObjectConverter<&kTodolistTodoListPointerType>>;
+-      CallHandler::CallSync(todolist_aa33_TodoList_new, aGlobal, aArgs, aReturnValue, "todolist_aa33_TodoList_new: "_ns, aError);
++      CallHandler::CallSync(todolist_cd5b_TodoList_new, aGlobal, aArgs, aReturnValue, "todolist_cd5b_TodoList_new: "_ns, aError);
+       return true;
+     }
+-    case 93: { // todolist:todolist_aa33_TodoList_add_item
++    case 93: { // todolist:todolist_cd5b_TodoList_add_item
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<void>, ScaffoldingObjectConverter<&kTodolistTodoListPointerType>, ScaffoldingConverter<RustBuffer>>;
+-      CallHandler::CallSync(todolist_aa33_TodoList_add_item, aGlobal, aArgs, aReturnValue, "todolist_aa33_TodoList_add_item: "_ns, aError);
++      CallHandler::CallSync(todolist_cd5b_TodoList_add_item, aGlobal, aArgs, aReturnValue, "todolist_cd5b_TodoList_add_item: "_ns, aError);
+       return true;
+     }
+-    case 94: { // todolist:todolist_aa33_TodoList_add_entry
++    case 94: { // todolist:todolist_cd5b_TodoList_add_entry
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<void>, ScaffoldingObjectConverter<&kTodolistTodoListPointerType>, ScaffoldingConverter<RustBuffer>>;
+-      CallHandler::CallSync(todolist_aa33_TodoList_add_entry, aGlobal, aArgs, aReturnValue, "todolist_aa33_TodoList_add_entry: "_ns, aError);
++      CallHandler::CallSync(todolist_cd5b_TodoList_add_entry, aGlobal, aArgs, aReturnValue, "todolist_cd5b_TodoList_add_entry: "_ns, aError);
+       return true;
+     }
+-    case 95: { // todolist:todolist_aa33_TodoList_get_entries
++    case 95: { // todolist:todolist_cd5b_TodoList_get_entries
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kTodolistTodoListPointerType>>;
+-      CallHandler::CallSync(todolist_aa33_TodoList_get_entries, aGlobal, aArgs, aReturnValue, "todolist_aa33_TodoList_get_entries: "_ns, aError);
++      CallHandler::CallSync(todolist_cd5b_TodoList_get_entries, aGlobal, aArgs, aReturnValue, "todolist_cd5b_TodoList_get_entries: "_ns, aError);
+       return true;
+     }
+-    case 96: { // todolist:todolist_aa33_TodoList_get_items
++    case 96: { // todolist:todolist_cd5b_TodoList_get_items
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kTodolistTodoListPointerType>>;
+-      CallHandler::CallSync(todolist_aa33_TodoList_get_items, aGlobal, aArgs, aReturnValue, "todolist_aa33_TodoList_get_items: "_ns, aError);
++      CallHandler::CallSync(todolist_cd5b_TodoList_get_items, aGlobal, aArgs, aReturnValue, "todolist_cd5b_TodoList_get_items: "_ns, aError);
+       return true;
+     }
+-    case 97: { // todolist:todolist_aa33_TodoList_add_entries
++    case 97: { // todolist:todolist_cd5b_TodoList_add_entries
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<void>, ScaffoldingObjectConverter<&kTodolistTodoListPointerType>, ScaffoldingConverter<RustBuffer>>;
+-      CallHandler::CallSync(todolist_aa33_TodoList_add_entries, aGlobal, aArgs, aReturnValue, "todolist_aa33_TodoList_add_entries: "_ns, aError);
++      CallHandler::CallSync(todolist_cd5b_TodoList_add_entries, aGlobal, aArgs, aReturnValue, "todolist_cd5b_TodoList_add_entries: "_ns, aError);
+       return true;
+     }
+-    case 98: { // todolist:todolist_aa33_TodoList_add_items
++    case 98: { // todolist:todolist_cd5b_TodoList_add_items
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<void>, ScaffoldingObjectConverter<&kTodolistTodoListPointerType>, ScaffoldingConverter<RustBuffer>>;
+-      CallHandler::CallSync(todolist_aa33_TodoList_add_items, aGlobal, aArgs, aReturnValue, "todolist_aa33_TodoList_add_items: "_ns, aError);
++      CallHandler::CallSync(todolist_cd5b_TodoList_add_items, aGlobal, aArgs, aReturnValue, "todolist_cd5b_TodoList_add_items: "_ns, aError);
+       return true;
+     }
+-    case 99: { // todolist:todolist_aa33_TodoList_get_last_entry
++    case 99: { // todolist:todolist_cd5b_TodoList_get_last_entry
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kTodolistTodoListPointerType>>;
+-      CallHandler::CallSync(todolist_aa33_TodoList_get_last_entry, aGlobal, aArgs, aReturnValue, "todolist_aa33_TodoList_get_last_entry: "_ns, aError);
++      CallHandler::CallSync(todolist_cd5b_TodoList_get_last_entry, aGlobal, aArgs, aReturnValue, "todolist_cd5b_TodoList_get_last_entry: "_ns, aError);
+       return true;
+     }
+-    case 100: { // todolist:todolist_aa33_TodoList_get_last
++    case 100: { // todolist:todolist_cd5b_TodoList_get_last
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kTodolistTodoListPointerType>>;
+-      CallHandler::CallSync(todolist_aa33_TodoList_get_last, aGlobal, aArgs, aReturnValue, "todolist_aa33_TodoList_get_last: "_ns, aError);
++      CallHandler::CallSync(todolist_cd5b_TodoList_get_last, aGlobal, aArgs, aReturnValue, "todolist_cd5b_TodoList_get_last: "_ns, aError);
+       return true;
+     }
+-    case 101: { // todolist:todolist_aa33_TodoList_get_first
++    case 101: { // todolist:todolist_cd5b_TodoList_get_first
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kTodolistTodoListPointerType>>;
+-      CallHandler::CallSync(todolist_aa33_TodoList_get_first, aGlobal, aArgs, aReturnValue, "todolist_aa33_TodoList_get_first: "_ns, aError);
++      CallHandler::CallSync(todolist_cd5b_TodoList_get_first, aGlobal, aArgs, aReturnValue, "todolist_cd5b_TodoList_get_first: "_ns, aError);
+       return true;
+     }
+-    case 102: { // todolist:todolist_aa33_TodoList_clear_item
++    case 102: { // todolist:todolist_cd5b_TodoList_clear_item
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<void>, ScaffoldingObjectConverter<&kTodolistTodoListPointerType>, ScaffoldingConverter<RustBuffer>>;
+-      CallHandler::CallSync(todolist_aa33_TodoList_clear_item, aGlobal, aArgs, aReturnValue, "todolist_aa33_TodoList_clear_item: "_ns, aError);
++      CallHandler::CallSync(todolist_cd5b_TodoList_clear_item, aGlobal, aArgs, aReturnValue, "todolist_cd5b_TodoList_clear_item: "_ns, aError);
+       return true;
+     }
+-    case 103: { // todolist:todolist_aa33_TodoList_make_default
++    case 103: { // todolist:todolist_cd5b_TodoList_make_default
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<void>, ScaffoldingObjectConverter<&kTodolistTodoListPointerType>>;
+-      CallHandler::CallSync(todolist_aa33_TodoList_make_default, aGlobal, aArgs, aReturnValue, "todolist_aa33_TodoList_make_default: "_ns, aError);
++      CallHandler::CallSync(todolist_cd5b_TodoList_make_default, aGlobal, aArgs, aReturnValue, "todolist_cd5b_TodoList_make_default: "_ns, aError);
+       return true;
+     }
+-    case 104: { // todolist:todolist_aa33_get_default_list
++    case 104: { // todolist:todolist_cd5b_get_default_list
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>>;
+-      CallHandler::CallSync(todolist_aa33_get_default_list, aGlobal, aArgs, aReturnValue, "todolist_aa33_get_default_list: "_ns, aError);
++      CallHandler::CallSync(todolist_cd5b_get_default_list, aGlobal, aArgs, aReturnValue, "todolist_cd5b_get_default_list: "_ns, aError);
+       return true;
+     }
+-    case 105: { // todolist:todolist_aa33_set_default_list
++    case 105: { // todolist:todolist_cd5b_set_default_list
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<void>, ScaffoldingObjectConverter<&kTodolistTodoListPointerType>>;
+-      CallHandler::CallSync(todolist_aa33_set_default_list, aGlobal, aArgs, aReturnValue, "todolist_aa33_set_default_list: "_ns, aError);
++      CallHandler::CallSync(todolist_cd5b_set_default_list, aGlobal, aArgs, aReturnValue, "todolist_cd5b_set_default_list: "_ns, aError);
+       return true;
+     }
+-    case 106: { // todolist:todolist_aa33_create_entry_with
++    case 106: { // todolist:todolist_cd5b_create_entry_with
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingConverter<RustBuffer>>;
+-      CallHandler::CallSync(todolist_aa33_create_entry_with, aGlobal, aArgs, aReturnValue, "todolist_aa33_create_entry_with: "_ns, aError);
++      CallHandler::CallSync(todolist_cd5b_create_entry_with, aGlobal, aArgs, aReturnValue, "todolist_cd5b_create_entry_with: "_ns, aError);
+       return true;
+     }
+-    case 107: { // custom_types:custom_types_8ecd_get_custom_types_demo
++    case 107: { // custom_types:custom_types_41fc_get_custom_types_demo
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingConverter<RustBuffer>>;
+-      CallHandler::CallSync(custom_types_8ecd_get_custom_types_demo, aGlobal, aArgs, aReturnValue, "custom_types_8ecd_get_custom_types_demo: "_ns, aError);
++      CallHandler::CallSync(custom_types_41fc_get_custom_types_demo, aGlobal, aArgs, aReturnValue, "custom_types_41fc_get_custom_types_demo: "_ns, aError);
+       return true;
+     }
+-    case 108: { // external_types:external_types_54cc_gradient
++    case 108: { // external_types:external_types_4cd4_gradient
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<double>, ScaffoldingConverter<RustBuffer>>;
+-      CallHandler::CallSync(external_types_54cc_gradient, aGlobal, aArgs, aReturnValue, "external_types_54cc_gradient: "_ns, aError);
++      CallHandler::CallSync(external_types_4cd4_gradient, aGlobal, aArgs, aReturnValue, "external_types_4cd4_gradient: "_ns, aError);
+       return true;
+     }
+   }
+diff -u -r --new-file firefox-108.0.orig/toolkit/components/uniffi-js/UniFFIGeneratedScaffolding.cpp firefox-108.0/toolkit/components/uniffi-js/UniFFIGeneratedScaffolding.cpp
+--- firefox-108.0.orig/toolkit/components/uniffi-js/UniFFIGeneratedScaffolding.cpp	2022-12-08 10:27:29.000000000 -0600
++++ firefox-108.0/toolkit/components/uniffi-js/UniFFIGeneratedScaffolding.cpp	2022-12-15 13:20:01.332880947 -0600
+@@ -19,121 +19,121 @@
+ 
+ // Define scaffolding functions from UniFFI
+ extern "C" {
+-  void ffi_tabs_4d51_TabsStore_object_free(void *, RustCallStatus*);
+-  void * tabs_4d51_TabsStore_new(RustBuffer, RustCallStatus*);
+-  RustBuffer tabs_4d51_TabsStore_get_all(void *, RustCallStatus*);
+-  void tabs_4d51_TabsStore_set_local_tabs(void *, RustBuffer, RustCallStatus*);
+-  void tabs_4d51_TabsStore_register_with_sync_manager(void *, RustCallStatus*);
+-  void tabs_4d51_TabsStore_reset(void *, RustCallStatus*);
+-  RustBuffer tabs_4d51_TabsStore_sync(void *, RustBuffer, RustBuffer, RustBuffer, RustBuffer, RustBuffer, RustCallStatus*);
+-  void * tabs_4d51_TabsStore_bridged_engine(void *, RustCallStatus*);
+-  void ffi_tabs_4d51_TabsBridgedEngine_object_free(void *, RustCallStatus*);
+-  int64_t tabs_4d51_TabsBridgedEngine_last_sync(void *, RustCallStatus*);
+-  void tabs_4d51_TabsBridgedEngine_set_last_sync(void *, int64_t, RustCallStatus*);
+-  RustBuffer tabs_4d51_TabsBridgedEngine_sync_id(void *, RustCallStatus*);
+-  RustBuffer tabs_4d51_TabsBridgedEngine_reset_sync_id(void *, RustCallStatus*);
+-  RustBuffer tabs_4d51_TabsBridgedEngine_ensure_current_sync_id(void *, RustBuffer, RustCallStatus*);
+-  void tabs_4d51_TabsBridgedEngine_prepare_for_sync(void *, RustBuffer, RustCallStatus*);
+-  void tabs_4d51_TabsBridgedEngine_sync_started(void *, RustCallStatus*);
+-  void tabs_4d51_TabsBridgedEngine_store_incoming(void *, RustBuffer, RustCallStatus*);
+-  RustBuffer tabs_4d51_TabsBridgedEngine_apply(void *, RustCallStatus*);
+-  void tabs_4d51_TabsBridgedEngine_set_uploaded(void *, int64_t, RustBuffer, RustCallStatus*);
+-  void tabs_4d51_TabsBridgedEngine_sync_finished(void *, RustCallStatus*);
+-  void tabs_4d51_TabsBridgedEngine_reset(void *, RustCallStatus*);
+-  void tabs_4d51_TabsBridgedEngine_wipe(void *, RustCallStatus*);
++  void ffi_tabs_1c79_TabsStore_object_free(void *, RustCallStatus*);
++  void * tabs_1c79_TabsStore_new(RustBuffer, RustCallStatus*);
++  RustBuffer tabs_1c79_TabsStore_get_all(void *, RustCallStatus*);
++  void tabs_1c79_TabsStore_set_local_tabs(void *, RustBuffer, RustCallStatus*);
++  void tabs_1c79_TabsStore_register_with_sync_manager(void *, RustCallStatus*);
++  void tabs_1c79_TabsStore_reset(void *, RustCallStatus*);
++  RustBuffer tabs_1c79_TabsStore_sync(void *, RustBuffer, RustBuffer, RustBuffer, RustBuffer, RustBuffer, RustCallStatus*);
++  void * tabs_1c79_TabsStore_bridged_engine(void *, RustCallStatus*);
++  void ffi_tabs_1c79_TabsBridgedEngine_object_free(void *, RustCallStatus*);
++  int64_t tabs_1c79_TabsBridgedEngine_last_sync(void *, RustCallStatus*);
++  void tabs_1c79_TabsBridgedEngine_set_last_sync(void *, int64_t, RustCallStatus*);
++  RustBuffer tabs_1c79_TabsBridgedEngine_sync_id(void *, RustCallStatus*);
++  RustBuffer tabs_1c79_TabsBridgedEngine_reset_sync_id(void *, RustCallStatus*);
++  RustBuffer tabs_1c79_TabsBridgedEngine_ensure_current_sync_id(void *, RustBuffer, RustCallStatus*);
++  void tabs_1c79_TabsBridgedEngine_prepare_for_sync(void *, RustBuffer, RustCallStatus*);
++  void tabs_1c79_TabsBridgedEngine_sync_started(void *, RustCallStatus*);
++  void tabs_1c79_TabsBridgedEngine_store_incoming(void *, RustBuffer, RustCallStatus*);
++  RustBuffer tabs_1c79_TabsBridgedEngine_apply(void *, RustCallStatus*);
++  void tabs_1c79_TabsBridgedEngine_set_uploaded(void *, int64_t, RustBuffer, RustCallStatus*);
++  void tabs_1c79_TabsBridgedEngine_sync_finished(void *, RustCallStatus*);
++  void tabs_1c79_TabsBridgedEngine_reset(void *, RustCallStatus*);
++  void tabs_1c79_TabsBridgedEngine_wipe(void *, RustCallStatus*);
+ }
+ 
+ // Define pointer types
+ const static mozilla::uniffi::UniFFIPointerType kTabsTabsStorePointerType {
+   "tabs::TabsStore"_ns,
+-  ffi_tabs_4d51_TabsStore_object_free
++  ffi_tabs_1c79_TabsStore_object_free
+ };
+ const static mozilla::uniffi::UniFFIPointerType kTabsTabsBridgedEnginePointerType {
+   "tabs::TabsBridgedEngine"_ns,
+-  ffi_tabs_4d51_TabsBridgedEngine_object_free
++  ffi_tabs_1c79_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_4d51_TabsStore_new
++    case 0: { // tabs:tabs_1c79_TabsStore_new
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingObjectConverter<&kTabsTabsStorePointerType>, ScaffoldingConverter<RustBuffer>>;
+-      return Some(CallHandler::CallAsync(tabs_4d51_TabsStore_new, aGlobal, aArgs, "tabs_4d51_TabsStore_new: "_ns, aError));
++      return Some(CallHandler::CallAsync(tabs_1c79_TabsStore_new, aGlobal, aArgs, "tabs_1c79_TabsStore_new: "_ns, aError));
+     }
+-    case 1: { // tabs:tabs_4d51_TabsStore_get_all
++    case 1: { // tabs:tabs_1c79_TabsStore_get_all
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kTabsTabsStorePointerType>>;
+-      return Some(CallHandler::CallAsync(tabs_4d51_TabsStore_get_all, aGlobal, aArgs, "tabs_4d51_TabsStore_get_all: "_ns, aError));
++      return Some(CallHandler::CallAsync(tabs_1c79_TabsStore_get_all, aGlobal, aArgs, "tabs_1c79_TabsStore_get_all: "_ns, aError));
+     }
+-    case 2: { // tabs:tabs_4d51_TabsStore_set_local_tabs
++    case 2: { // tabs:tabs_1c79_TabsStore_set_local_tabs
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<void>, ScaffoldingObjectConverter<&kTabsTabsStorePointerType>, ScaffoldingConverter<RustBuffer>>;
+-      return Some(CallHandler::CallAsync(tabs_4d51_TabsStore_set_local_tabs, aGlobal, aArgs, "tabs_4d51_TabsStore_set_local_tabs: "_ns, aError));
++      return Some(CallHandler::CallAsync(tabs_1c79_TabsStore_set_local_tabs, aGlobal, aArgs, "tabs_1c79_TabsStore_set_local_tabs: "_ns, aError));
+     }
+-    case 3: { // tabs:tabs_4d51_TabsStore_register_with_sync_manager
++    case 3: { // tabs:tabs_1c79_TabsStore_register_with_sync_manager
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<void>, ScaffoldingObjectConverter<&kTabsTabsStorePointerType>>;
+-      return Some(CallHandler::CallAsync(tabs_4d51_TabsStore_register_with_sync_manager, aGlobal, aArgs, "tabs_4d51_TabsStore_register_with_sync_manager: "_ns, aError));
++      return Some(CallHandler::CallAsync(tabs_1c79_TabsStore_register_with_sync_manager, aGlobal, aArgs, "tabs_1c79_TabsStore_register_with_sync_manager: "_ns, aError));
+     }
+-    case 4: { // tabs:tabs_4d51_TabsStore_reset
++    case 4: { // tabs:tabs_1c79_TabsStore_reset
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<void>, ScaffoldingObjectConverter<&kTabsTabsStorePointerType>>;
+-      return Some(CallHandler::CallAsync(tabs_4d51_TabsStore_reset, aGlobal, aArgs, "tabs_4d51_TabsStore_reset: "_ns, aError));
++      return Some(CallHandler::CallAsync(tabs_1c79_TabsStore_reset, aGlobal, aArgs, "tabs_1c79_TabsStore_reset: "_ns, aError));
+     }
+-    case 5: { // tabs:tabs_4d51_TabsStore_sync
++    case 5: { // tabs:tabs_1c79_TabsStore_sync
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kTabsTabsStorePointerType>, ScaffoldingConverter<RustBuffer>, ScaffoldingConverter<RustBuffer>, ScaffoldingConverter<RustBuffer>, ScaffoldingConverter<RustBuffer>, ScaffoldingConverter<RustBuffer>>;
+-      return Some(CallHandler::CallAsync(tabs_4d51_TabsStore_sync, aGlobal, aArgs, "tabs_4d51_TabsStore_sync: "_ns, aError));
++      return Some(CallHandler::CallAsync(tabs_1c79_TabsStore_sync, aGlobal, aArgs, "tabs_1c79_TabsStore_sync: "_ns, aError));
+     }
+-    case 6: { // tabs:tabs_4d51_TabsStore_bridged_engine
++    case 6: { // tabs:tabs_1c79_TabsStore_bridged_engine
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>, ScaffoldingObjectConverter<&kTabsTabsStorePointerType>>;
+-      return Some(CallHandler::CallAsync(tabs_4d51_TabsStore_bridged_engine, aGlobal, aArgs, "tabs_4d51_TabsStore_bridged_engine: "_ns, aError));
++      return Some(CallHandler::CallAsync(tabs_1c79_TabsStore_bridged_engine, aGlobal, aArgs, "tabs_1c79_TabsStore_bridged_engine: "_ns, aError));
+     }
+-    case 7: { // tabs:tabs_4d51_TabsBridgedEngine_last_sync
++    case 7: { // tabs:tabs_1c79_TabsBridgedEngine_last_sync
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<int64_t>, ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>>;
+-      return Some(CallHandler::CallAsync(tabs_4d51_TabsBridgedEngine_last_sync, aGlobal, aArgs, "tabs_4d51_TabsBridgedEngine_last_sync: "_ns, aError));
++      return Some(CallHandler::CallAsync(tabs_1c79_TabsBridgedEngine_last_sync, aGlobal, aArgs, "tabs_1c79_TabsBridgedEngine_last_sync: "_ns, aError));
+     }
+-    case 8: { // tabs:tabs_4d51_TabsBridgedEngine_set_last_sync
++    case 8: { // tabs:tabs_1c79_TabsBridgedEngine_set_last_sync
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<void>, ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>, ScaffoldingConverter<int64_t>>;
+-      return Some(CallHandler::CallAsync(tabs_4d51_TabsBridgedEngine_set_last_sync, aGlobal, aArgs, "tabs_4d51_TabsBridgedEngine_set_last_sync: "_ns, aError));
++      return Some(CallHandler::CallAsync(tabs_1c79_TabsBridgedEngine_set_last_sync, aGlobal, aArgs, "tabs_1c79_TabsBridgedEngine_set_last_sync: "_ns, aError));
+     }
+-    case 9: { // tabs:tabs_4d51_TabsBridgedEngine_sync_id
++    case 9: { // tabs:tabs_1c79_TabsBridgedEngine_sync_id
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>>;
+-      return Some(CallHandler::CallAsync(tabs_4d51_TabsBridgedEngine_sync_id, aGlobal, aArgs, "tabs_4d51_TabsBridgedEngine_sync_id: "_ns, aError));
++      return Some(CallHandler::CallAsync(tabs_1c79_TabsBridgedEngine_sync_id, aGlobal, aArgs, "tabs_1c79_TabsBridgedEngine_sync_id: "_ns, aError));
+     }
+-    case 10: { // tabs:tabs_4d51_TabsBridgedEngine_reset_sync_id
++    case 10: { // tabs:tabs_1c79_TabsBridgedEngine_reset_sync_id
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>>;
+-      return Some(CallHandler::CallAsync(tabs_4d51_TabsBridgedEngine_reset_sync_id, aGlobal, aArgs, "tabs_4d51_TabsBridgedEngine_reset_sync_id: "_ns, aError));
++      return Some(CallHandler::CallAsync(tabs_1c79_TabsBridgedEngine_reset_sync_id, aGlobal, aArgs, "tabs_1c79_TabsBridgedEngine_reset_sync_id: "_ns, aError));
+     }
+-    case 11: { // tabs:tabs_4d51_TabsBridgedEngine_ensure_current_sync_id
++    case 11: { // tabs:tabs_1c79_TabsBridgedEngine_ensure_current_sync_id
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>, ScaffoldingConverter<RustBuffer>>;
+-      return Some(CallHandler::CallAsync(tabs_4d51_TabsBridgedEngine_ensure_current_sync_id, aGlobal, aArgs, "tabs_4d51_TabsBridgedEngine_ensure_current_sync_id: "_ns, aError));
++      return Some(CallHandler::CallAsync(tabs_1c79_TabsBridgedEngine_ensure_current_sync_id, aGlobal, aArgs, "tabs_1c79_TabsBridgedEngine_ensure_current_sync_id: "_ns, aError));
+     }
+-    case 12: { // tabs:tabs_4d51_TabsBridgedEngine_prepare_for_sync
++    case 12: { // tabs:tabs_1c79_TabsBridgedEngine_prepare_for_sync
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<void>, ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>, ScaffoldingConverter<RustBuffer>>;
+-      return Some(CallHandler::CallAsync(tabs_4d51_TabsBridgedEngine_prepare_for_sync, aGlobal, aArgs, "tabs_4d51_TabsBridgedEngine_prepare_for_sync: "_ns, aError));
++      return Some(CallHandler::CallAsync(tabs_1c79_TabsBridgedEngine_prepare_for_sync, aGlobal, aArgs, "tabs_1c79_TabsBridgedEngine_prepare_for_sync: "_ns, aError));
+     }
+-    case 13: { // tabs:tabs_4d51_TabsBridgedEngine_sync_started
++    case 13: { // tabs:tabs_1c79_TabsBridgedEngine_sync_started
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<void>, ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>>;
+-      return Some(CallHandler::CallAsync(tabs_4d51_TabsBridgedEngine_sync_started, aGlobal, aArgs, "tabs_4d51_TabsBridgedEngine_sync_started: "_ns, aError));
++      return Some(CallHandler::CallAsync(tabs_1c79_TabsBridgedEngine_sync_started, aGlobal, aArgs, "tabs_1c79_TabsBridgedEngine_sync_started: "_ns, aError));
+     }
+-    case 14: { // tabs:tabs_4d51_TabsBridgedEngine_store_incoming
++    case 14: { // tabs:tabs_1c79_TabsBridgedEngine_store_incoming
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<void>, ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>, ScaffoldingConverter<RustBuffer>>;
+-      return Some(CallHandler::CallAsync(tabs_4d51_TabsBridgedEngine_store_incoming, aGlobal, aArgs, "tabs_4d51_TabsBridgedEngine_store_incoming: "_ns, aError));
++      return Some(CallHandler::CallAsync(tabs_1c79_TabsBridgedEngine_store_incoming, aGlobal, aArgs, "tabs_1c79_TabsBridgedEngine_store_incoming: "_ns, aError));
+     }
+-    case 15: { // tabs:tabs_4d51_TabsBridgedEngine_apply
++    case 15: { // tabs:tabs_1c79_TabsBridgedEngine_apply
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>>;
+-      return Some(CallHandler::CallAsync(tabs_4d51_TabsBridgedEngine_apply, aGlobal, aArgs, "tabs_4d51_TabsBridgedEngine_apply: "_ns, aError));
++      return Some(CallHandler::CallAsync(tabs_1c79_TabsBridgedEngine_apply, aGlobal, aArgs, "tabs_1c79_TabsBridgedEngine_apply: "_ns, aError));
+     }
+-    case 16: { // tabs:tabs_4d51_TabsBridgedEngine_set_uploaded
++    case 16: { // tabs:tabs_1c79_TabsBridgedEngine_set_uploaded
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<void>, ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>, ScaffoldingConverter<int64_t>, ScaffoldingConverter<RustBuffer>>;
+-      return Some(CallHandler::CallAsync(tabs_4d51_TabsBridgedEngine_set_uploaded, aGlobal, aArgs, "tabs_4d51_TabsBridgedEngine_set_uploaded: "_ns, aError));
++      return Some(CallHandler::CallAsync(tabs_1c79_TabsBridgedEngine_set_uploaded, aGlobal, aArgs, "tabs_1c79_TabsBridgedEngine_set_uploaded: "_ns, aError));
+     }
+-    case 17: { // tabs:tabs_4d51_TabsBridgedEngine_sync_finished
++    case 17: { // tabs:tabs_1c79_TabsBridgedEngine_sync_finished
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<void>, ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>>;
+-      return Some(CallHandler::CallAsync(tabs_4d51_TabsBridgedEngine_sync_finished, aGlobal, aArgs, "tabs_4d51_TabsBridgedEngine_sync_finished: "_ns, aError));
++      return Some(CallHandler::CallAsync(tabs_1c79_TabsBridgedEngine_sync_finished, aGlobal, aArgs, "tabs_1c79_TabsBridgedEngine_sync_finished: "_ns, aError));
+     }
+-    case 18: { // tabs:tabs_4d51_TabsBridgedEngine_reset
++    case 18: { // tabs:tabs_1c79_TabsBridgedEngine_reset
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<void>, ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>>;
+-      return Some(CallHandler::CallAsync(tabs_4d51_TabsBridgedEngine_reset, aGlobal, aArgs, "tabs_4d51_TabsBridgedEngine_reset: "_ns, aError));
++      return Some(CallHandler::CallAsync(tabs_1c79_TabsBridgedEngine_reset, aGlobal, aArgs, "tabs_1c79_TabsBridgedEngine_reset: "_ns, aError));
+     }
+-    case 19: { // tabs:tabs_4d51_TabsBridgedEngine_wipe
++    case 19: { // tabs:tabs_1c79_TabsBridgedEngine_wipe
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<void>, ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>>;
+-      return Some(CallHandler::CallAsync(tabs_4d51_TabsBridgedEngine_wipe, aGlobal, aArgs, "tabs_4d51_TabsBridgedEngine_wipe: "_ns, aError));
++      return Some(CallHandler::CallAsync(tabs_1c79_TabsBridgedEngine_wipe, aGlobal, aArgs, "tabs_1c79_TabsBridgedEngine_wipe: "_ns, aError));
+     }
+   }
+   return Nothing();
+@@ -141,104 +141,104 @@
+ 
+ bool UniFFICallSync(const GlobalObject& aGlobal, uint64_t aId, const Sequence<ScaffoldingType>& aArgs, RootedDictionary<UniFFIScaffoldingCallResult>& aReturnValue, ErrorResult& aError) {
+   switch (aId) {
+-    case 0: { // tabs:tabs_4d51_TabsStore_new
++    case 0: { // tabs:tabs_1c79_TabsStore_new
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingObjectConverter<&kTabsTabsStorePointerType>, ScaffoldingConverter<RustBuffer>>;
+-      CallHandler::CallSync(tabs_4d51_TabsStore_new, aGlobal, aArgs, aReturnValue, "tabs_4d51_TabsStore_new: "_ns, aError);
++      CallHandler::CallSync(tabs_1c79_TabsStore_new, aGlobal, aArgs, aReturnValue, "tabs_1c79_TabsStore_new: "_ns, aError);
+       return true;
+     }
+-    case 1: { // tabs:tabs_4d51_TabsStore_get_all
++    case 1: { // tabs:tabs_1c79_TabsStore_get_all
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kTabsTabsStorePointerType>>;
+-      CallHandler::CallSync(tabs_4d51_TabsStore_get_all, aGlobal, aArgs, aReturnValue, "tabs_4d51_TabsStore_get_all: "_ns, aError);
++      CallHandler::CallSync(tabs_1c79_TabsStore_get_all, aGlobal, aArgs, aReturnValue, "tabs_1c79_TabsStore_get_all: "_ns, aError);
+       return true;
+     }
+-    case 2: { // tabs:tabs_4d51_TabsStore_set_local_tabs
++    case 2: { // tabs:tabs_1c79_TabsStore_set_local_tabs
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<void>, ScaffoldingObjectConverter<&kTabsTabsStorePointerType>, ScaffoldingConverter<RustBuffer>>;
+-      CallHandler::CallSync(tabs_4d51_TabsStore_set_local_tabs, aGlobal, aArgs, aReturnValue, "tabs_4d51_TabsStore_set_local_tabs: "_ns, aError);
++      CallHandler::CallSync(tabs_1c79_TabsStore_set_local_tabs, aGlobal, aArgs, aReturnValue, "tabs_1c79_TabsStore_set_local_tabs: "_ns, aError);
+       return true;
+     }
+-    case 3: { // tabs:tabs_4d51_TabsStore_register_with_sync_manager
++    case 3: { // tabs:tabs_1c79_TabsStore_register_with_sync_manager
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<void>, ScaffoldingObjectConverter<&kTabsTabsStorePointerType>>;
+-      CallHandler::CallSync(tabs_4d51_TabsStore_register_with_sync_manager, aGlobal, aArgs, aReturnValue, "tabs_4d51_TabsStore_register_with_sync_manager: "_ns, aError);
++      CallHandler::CallSync(tabs_1c79_TabsStore_register_with_sync_manager, aGlobal, aArgs, aReturnValue, "tabs_1c79_TabsStore_register_with_sync_manager: "_ns, aError);
+       return true;
+     }
+-    case 4: { // tabs:tabs_4d51_TabsStore_reset
++    case 4: { // tabs:tabs_1c79_TabsStore_reset
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<void>, ScaffoldingObjectConverter<&kTabsTabsStorePointerType>>;
+-      CallHandler::CallSync(tabs_4d51_TabsStore_reset, aGlobal, aArgs, aReturnValue, "tabs_4d51_TabsStore_reset: "_ns, aError);
++      CallHandler::CallSync(tabs_1c79_TabsStore_reset, aGlobal, aArgs, aReturnValue, "tabs_1c79_TabsStore_reset: "_ns, aError);
+       return true;
+     }
+-    case 5: { // tabs:tabs_4d51_TabsStore_sync
++    case 5: { // tabs:tabs_1c79_TabsStore_sync
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kTabsTabsStorePointerType>, ScaffoldingConverter<RustBuffer>, ScaffoldingConverter<RustBuffer>, ScaffoldingConverter<RustBuffer>, ScaffoldingConverter<RustBuffer>, ScaffoldingConverter<RustBuffer>>;
+-      CallHandler::CallSync(tabs_4d51_TabsStore_sync, aGlobal, aArgs, aReturnValue, "tabs_4d51_TabsStore_sync: "_ns, aError);
++      CallHandler::CallSync(tabs_1c79_TabsStore_sync, aGlobal, aArgs, aReturnValue, "tabs_1c79_TabsStore_sync: "_ns, aError);
+       return true;
+     }
+-    case 6: { // tabs:tabs_4d51_TabsStore_bridged_engine
++    case 6: { // tabs:tabs_1c79_TabsStore_bridged_engine
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>, ScaffoldingObjectConverter<&kTabsTabsStorePointerType>>;
+-      CallHandler::CallSync(tabs_4d51_TabsStore_bridged_engine, aGlobal, aArgs, aReturnValue, "tabs_4d51_TabsStore_bridged_engine: "_ns, aError);
++      CallHandler::CallSync(tabs_1c79_TabsStore_bridged_engine, aGlobal, aArgs, aReturnValue, "tabs_1c79_TabsStore_bridged_engine: "_ns, aError);
+       return true;
+     }
+-    case 7: { // tabs:tabs_4d51_TabsBridgedEngine_last_sync
++    case 7: { // tabs:tabs_1c79_TabsBridgedEngine_last_sync
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<int64_t>, ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>>;
+-      CallHandler::CallSync(tabs_4d51_TabsBridgedEngine_last_sync, aGlobal, aArgs, aReturnValue, "tabs_4d51_TabsBridgedEngine_last_sync: "_ns, aError);
++      CallHandler::CallSync(tabs_1c79_TabsBridgedEngine_last_sync, aGlobal, aArgs, aReturnValue, "tabs_1c79_TabsBridgedEngine_last_sync: "_ns, aError);
+       return true;
+     }
+-    case 8: { // tabs:tabs_4d51_TabsBridgedEngine_set_last_sync
++    case 8: { // tabs:tabs_1c79_TabsBridgedEngine_set_last_sync
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<void>, ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>, ScaffoldingConverter<int64_t>>;
+-      CallHandler::CallSync(tabs_4d51_TabsBridgedEngine_set_last_sync, aGlobal, aArgs, aReturnValue, "tabs_4d51_TabsBridgedEngine_set_last_sync: "_ns, aError);
++      CallHandler::CallSync(tabs_1c79_TabsBridgedEngine_set_last_sync, aGlobal, aArgs, aReturnValue, "tabs_1c79_TabsBridgedEngine_set_last_sync: "_ns, aError);
+       return true;
+     }
+-    case 9: { // tabs:tabs_4d51_TabsBridgedEngine_sync_id
++    case 9: { // tabs:tabs_1c79_TabsBridgedEngine_sync_id
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>>;
+-      CallHandler::CallSync(tabs_4d51_TabsBridgedEngine_sync_id, aGlobal, aArgs, aReturnValue, "tabs_4d51_TabsBridgedEngine_sync_id: "_ns, aError);
++      CallHandler::CallSync(tabs_1c79_TabsBridgedEngine_sync_id, aGlobal, aArgs, aReturnValue, "tabs_1c79_TabsBridgedEngine_sync_id: "_ns, aError);
+       return true;
+     }
+-    case 10: { // tabs:tabs_4d51_TabsBridgedEngine_reset_sync_id
++    case 10: { // tabs:tabs_1c79_TabsBridgedEngine_reset_sync_id
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>>;
+-      CallHandler::CallSync(tabs_4d51_TabsBridgedEngine_reset_sync_id, aGlobal, aArgs, aReturnValue, "tabs_4d51_TabsBridgedEngine_reset_sync_id: "_ns, aError);
++      CallHandler::CallSync(tabs_1c79_TabsBridgedEngine_reset_sync_id, aGlobal, aArgs, aReturnValue, "tabs_1c79_TabsBridgedEngine_reset_sync_id: "_ns, aError);
+       return true;
+     }
+-    case 11: { // tabs:tabs_4d51_TabsBridgedEngine_ensure_current_sync_id
++    case 11: { // tabs:tabs_1c79_TabsBridgedEngine_ensure_current_sync_id
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>, ScaffoldingConverter<RustBuffer>>;
+-      CallHandler::CallSync(tabs_4d51_TabsBridgedEngine_ensure_current_sync_id, aGlobal, aArgs, aReturnValue, "tabs_4d51_TabsBridgedEngine_ensure_current_sync_id: "_ns, aError);
++      CallHandler::CallSync(tabs_1c79_TabsBridgedEngine_ensure_current_sync_id, aGlobal, aArgs, aReturnValue, "tabs_1c79_TabsBridgedEngine_ensure_current_sync_id: "_ns, aError);
+       return true;
+     }
+-    case 12: { // tabs:tabs_4d51_TabsBridgedEngine_prepare_for_sync
++    case 12: { // tabs:tabs_1c79_TabsBridgedEngine_prepare_for_sync
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<void>, ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>, ScaffoldingConverter<RustBuffer>>;
+-      CallHandler::CallSync(tabs_4d51_TabsBridgedEngine_prepare_for_sync, aGlobal, aArgs, aReturnValue, "tabs_4d51_TabsBridgedEngine_prepare_for_sync: "_ns, aError);
++      CallHandler::CallSync(tabs_1c79_TabsBridgedEngine_prepare_for_sync, aGlobal, aArgs, aReturnValue, "tabs_1c79_TabsBridgedEngine_prepare_for_sync: "_ns, aError);
+       return true;
+     }
+-    case 13: { // tabs:tabs_4d51_TabsBridgedEngine_sync_started
++    case 13: { // tabs:tabs_1c79_TabsBridgedEngine_sync_started
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<void>, ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>>;
+-      CallHandler::CallSync(tabs_4d51_TabsBridgedEngine_sync_started, aGlobal, aArgs, aReturnValue, "tabs_4d51_TabsBridgedEngine_sync_started: "_ns, aError);
++      CallHandler::CallSync(tabs_1c79_TabsBridgedEngine_sync_started, aGlobal, aArgs, aReturnValue, "tabs_1c79_TabsBridgedEngine_sync_started: "_ns, aError);
+       return true;
+     }
+-    case 14: { // tabs:tabs_4d51_TabsBridgedEngine_store_incoming
++    case 14: { // tabs:tabs_1c79_TabsBridgedEngine_store_incoming
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<void>, ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>, ScaffoldingConverter<RustBuffer>>;
+-      CallHandler::CallSync(tabs_4d51_TabsBridgedEngine_store_incoming, aGlobal, aArgs, aReturnValue, "tabs_4d51_TabsBridgedEngine_store_incoming: "_ns, aError);
++      CallHandler::CallSync(tabs_1c79_TabsBridgedEngine_store_incoming, aGlobal, aArgs, aReturnValue, "tabs_1c79_TabsBridgedEngine_store_incoming: "_ns, aError);
+       return true;
+     }
+-    case 15: { // tabs:tabs_4d51_TabsBridgedEngine_apply
++    case 15: { // tabs:tabs_1c79_TabsBridgedEngine_apply
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<RustBuffer>, ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>>;
+-      CallHandler::CallSync(tabs_4d51_TabsBridgedEngine_apply, aGlobal, aArgs, aReturnValue, "tabs_4d51_TabsBridgedEngine_apply: "_ns, aError);
++      CallHandler::CallSync(tabs_1c79_TabsBridgedEngine_apply, aGlobal, aArgs, aReturnValue, "tabs_1c79_TabsBridgedEngine_apply: "_ns, aError);
+       return true;
+     }
+-    case 16: { // tabs:tabs_4d51_TabsBridgedEngine_set_uploaded
++    case 16: { // tabs:tabs_1c79_TabsBridgedEngine_set_uploaded
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<void>, ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>, ScaffoldingConverter<int64_t>, ScaffoldingConverter<RustBuffer>>;
+-      CallHandler::CallSync(tabs_4d51_TabsBridgedEngine_set_uploaded, aGlobal, aArgs, aReturnValue, "tabs_4d51_TabsBridgedEngine_set_uploaded: "_ns, aError);
++      CallHandler::CallSync(tabs_1c79_TabsBridgedEngine_set_uploaded, aGlobal, aArgs, aReturnValue, "tabs_1c79_TabsBridgedEngine_set_uploaded: "_ns, aError);
+       return true;
+     }
+-    case 17: { // tabs:tabs_4d51_TabsBridgedEngine_sync_finished
++    case 17: { // tabs:tabs_1c79_TabsBridgedEngine_sync_finished
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<void>, ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>>;
+-      CallHandler::CallSync(tabs_4d51_TabsBridgedEngine_sync_finished, aGlobal, aArgs, aReturnValue, "tabs_4d51_TabsBridgedEngine_sync_finished: "_ns, aError);
++      CallHandler::CallSync(tabs_1c79_TabsBridgedEngine_sync_finished, aGlobal, aArgs, aReturnValue, "tabs_1c79_TabsBridgedEngine_sync_finished: "_ns, aError);
+       return true;
+     }
+-    case 18: { // tabs:tabs_4d51_TabsBridgedEngine_reset
++    case 18: { // tabs:tabs_1c79_TabsBridgedEngine_reset
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<void>, ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>>;
+-      CallHandler::CallSync(tabs_4d51_TabsBridgedEngine_reset, aGlobal, aArgs, aReturnValue, "tabs_4d51_TabsBridgedEngine_reset: "_ns, aError);
++      CallHandler::CallSync(tabs_1c79_TabsBridgedEngine_reset, aGlobal, aArgs, aReturnValue, "tabs_1c79_TabsBridgedEngine_reset: "_ns, aError);
+       return true;
+     }
+-    case 19: { // tabs:tabs_4d51_TabsBridgedEngine_wipe
++    case 19: { // tabs:tabs_1c79_TabsBridgedEngine_wipe
+       using CallHandler = ScaffoldingCallHandler<ScaffoldingConverter<void>, ScaffoldingObjectConverter<&kTabsTabsBridgedEnginePointerType>>;
+-      CallHandler::CallSync(tabs_4d51_TabsBridgedEngine_wipe, aGlobal, aArgs, aReturnValue, "tabs_4d51_TabsBridgedEngine_wipe: "_ns, aError);
++      CallHandler::CallSync(tabs_1c79_TabsBridgedEngine_wipe, aGlobal, aArgs, aReturnValue, "tabs_1c79_TabsBridgedEngine_wipe: "_ns, aError);
+       return true;
+     }
+   }
diff --git a/source/xap/mozilla-thunderbird/mozilla-thunderbird.SlackBuild b/source/xap/mozilla-thunderbird/mozilla-thunderbird.SlackBuild
index c5730f5d6..b4efb59f0 100755
--- a/source/xap/mozilla-thunderbird/mozilla-thunderbird.SlackBuild
+++ b/source/xap/mozilla-thunderbird/mozilla-thunderbird.SlackBuild
@@ -317,20 +317,6 @@ mkdir -p $PKG/usr/share/pixmaps
 # Symlinked below.
 #cat $CWD/thunderbird.png > $PKG/usr/share/pixmaps/thunderbird.png
 
-# These files/directories are usually created if Thunderbird is run as root,
-# which on many systems might (and possibly should) be never.  Therefore, if we
-# don't see them we'll put stubs in place to prevent startup errors.
-( cd $PKG/usr/lib${LIBDIRSUFFIX}/thunderbird-$RELEASEVER
-  if [ -d extensions/talkback\@mozilla.org ]; then
-    if [ ! -r extensions/talkback\@mozilla.org/chrome.manifest ]; then
-      echo > extensions/talkback\@mozilla.org/chrome.manifest
-    fi
-  fi
-  if [ ! -d updates ]; then
-    mkdir -p updates/0
-  fi
-)
-
 # Need some default icons in the right place:
 for i in 16 22 24 32 48 256; do
   install -m 0644 -D comm/mail/branding/thunderbird/default${i}.png \