diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 0232bdaa..c77982cc 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -12,7 +12,7 @@ jobs:
       - uses: actions/checkout@v4
       - uses: actions/setup-java@v4
         with:
-          java-version: 21
+          java-version: 22
           distribution: 'zulu'
           cache: 'maven'
       - name: Setup fuse
@@ -35,7 +35,7 @@ jobs:
       - uses: actions/checkout@v4
       - uses: actions/setup-java@v4
         with:
-          java-version: 21
+          java-version: 22
           distribution: 'zulu'
           cache: 'maven'
       - name: Setup fuse
@@ -59,7 +59,7 @@ jobs:
       - uses: actions/checkout@v4
       - uses: actions/setup-java@v4
         with:
-          java-version: 21
+          java-version: 22
           distribution: 'zulu'
           cache: 'maven'
       - name: Setup fuse
@@ -83,7 +83,7 @@ jobs:
            fetch-depth: 0
       - uses: actions/setup-java@v4
         with:
-          java-version: 21
+          java-version: 22
           distribution: 'zulu'
           cache: 'maven'
       - name: Cache SonarCloud packages
diff --git a/.github/workflows/publish-central.yml b/.github/workflows/publish-central.yml
index 1916bd8e..633a579b 100644
--- a/.github/workflows/publish-central.yml
+++ b/.github/workflows/publish-central.yml
@@ -15,7 +15,7 @@ jobs:
           ref: "refs/tags/${{ github.event.inputs.tag }}"
       - uses: actions/setup-java@v4
         with:
-          java-version: 21
+          java-version: 22
           distribution: 'zulu'
           cache: 'maven'
           server-id: ossrh # Value of the distributionManagement/repository/id field of the pom.xml
diff --git a/.github/workflows/publish-github.yml b/.github/workflows/publish-github.yml
index 5b9df1cd..0ab2eec1 100644
--- a/.github/workflows/publish-github.yml
+++ b/.github/workflows/publish-github.yml
@@ -10,7 +10,7 @@ jobs:
       - uses: actions/checkout@v4
       - uses: actions/setup-java@v4
         with:
-          java-version: 21
+          java-version: 22
           distribution: 'zulu'
           cache: 'maven'
           gpg-private-key: ${{ secrets.RELEASES_GPG_PRIVATE_KEY }} # Value of the GPG private key to import
diff --git a/.idea/misc.xml b/.idea/misc.xml
index ee700a1c..bf795660 100644
--- a/.idea/misc.xml
+++ b/.idea/misc.xml
@@ -8,7 +8,7 @@
       </list>
     </option>
   </component>
-  <component name="ProjectRootManager" version="2" languageLevel="JDK_21_PREVIEW" project-jdk-name="21" project-jdk-type="JavaSDK">
+  <component name="ProjectRootManager" version="2" languageLevel="JDK_21_PREVIEW" project-jdk-name="22" project-jdk-type="JavaSDK">
     <output url="file://$PROJECT_DIR$/out" />
   </component>
 </project>
\ No newline at end of file
diff --git a/.idea/runConfigurations/HelloWorldFileSystem.xml b/.idea/runConfigurations/HelloWorldFileSystem.xml
index 6a52e270..a5fc63c7 100644
--- a/.idea/runConfigurations/HelloWorldFileSystem.xml
+++ b/.idea/runConfigurations/HelloWorldFileSystem.xml
@@ -3,7 +3,7 @@
     <option name="MAIN_CLASS_NAME" value="org.cryptomator.jfuse.examples.HelloWorldFileSystem" />
     <module name="jfuse-examples" />
     <option name="PROGRAM_PARAMETERS" value="/Volumes/foo" />
-    <option name="VM_PARAMETERS" value="-Djava.library.path=/usr/local/lib -Dorg.slf4j.simpleLogger.defaultLogLevel=info --enable-native-access=org.cryptomator.jfuse.linux.amd64,org.cryptomator.jfuse.mac,org.cryptomator.jfuse.win --enable-preview" />
+    <option name="VM_PARAMETERS" value="-Djava.library.path=/usr/local/lib -Dorg.slf4j.simpleLogger.defaultLogLevel=info --enable-native-access=org.cryptomator.jfuse.linux.amd64,org.cryptomator.jfuse.mac,org.cryptomator.jfuse.win" />
     <method v="2">
       <option name="Make" enabled="true" />
     </method>
diff --git a/.idea/runConfigurations/HelloWorldFileSystem__Windows_.xml b/.idea/runConfigurations/HelloWorldFileSystem__Windows_.xml
index 3e13b6fe..aeacd124 100644
--- a/.idea/runConfigurations/HelloWorldFileSystem__Windows_.xml
+++ b/.idea/runConfigurations/HelloWorldFileSystem__Windows_.xml
@@ -3,7 +3,7 @@
     <option name="MAIN_CLASS_NAME" value="org.cryptomator.jfuse.examples.HelloWorldFileSystem" />
     <module name="jfuse-examples" />
     <option name="PROGRAM_PARAMETERS" value="Z:/" />
-    <option name="VM_PARAMETERS" value="-Djava.library.path=/usr/local/lib -Dorg.slf4j.simpleLogger.defaultLogLevel=info --enable-native-access=org.cryptomator.jfuse.linux.amd64,org.cryptomator.jfuse.mac,org.cryptomator.jfuse.win --enable-preview" />
+    <option name="VM_PARAMETERS" value="-Djava.library.path=/usr/local/lib -Dorg.slf4j.simpleLogger.defaultLogLevel=info --enable-native-access=org.cryptomator.jfuse.linux.amd64,org.cryptomator.jfuse.mac,org.cryptomator.jfuse.win" />
     <method v="2">
       <option name="Make" enabled="true" />
     </method>
diff --git a/.idea/runConfigurations/PosixMirrorFileSystem__Linux_.xml b/.idea/runConfigurations/PosixMirrorFileSystem__Linux_.xml
index 3b450f39..4be5ada7 100644
--- a/.idea/runConfigurations/PosixMirrorFileSystem__Linux_.xml
+++ b/.idea/runConfigurations/PosixMirrorFileSystem__Linux_.xml
@@ -3,7 +3,7 @@
     <option name="MAIN_CLASS_NAME" value="org.cryptomator.jfuse.examples.PosixMirrorFileSystem" />
     <module name="jfuse-examples" />
     <option name="PROGRAM_PARAMETERS" value="/home/sebastian/Desktop/TMP /tmp/mount" />
-    <option name="VM_PARAMETERS" value="-Djava.library.path=/usr/local/lib -Dorg.slf4j.simpleLogger.defaultLogLevel=debug --enable-native-access=org.cryptomator.jfuse.linux.amd64,org.cryptomator.jfuse.linux.aarch64 --enable-preview" />
+    <option name="VM_PARAMETERS" value="-Djava.library.path=/usr/local/lib -Dorg.slf4j.simpleLogger.defaultLogLevel=debug --enable-native-access=org.cryptomator.jfuse.linux.amd64,org.cryptomator.jfuse.linux.aarch64" />
     <extension name="coverage">
       <pattern>
         <option name="PATTERN" value="de.skymatic.fusepanama.examples.*" />
diff --git a/.idea/runConfigurations/PosixMirrorFileSystem__fuse_t_.xml b/.idea/runConfigurations/PosixMirrorFileSystem__fuse_t_.xml
index 6a177fcc..eba2a66b 100644
--- a/.idea/runConfigurations/PosixMirrorFileSystem__fuse_t_.xml
+++ b/.idea/runConfigurations/PosixMirrorFileSystem__fuse_t_.xml
@@ -3,7 +3,7 @@
     <option name="MAIN_CLASS_NAME" value="org.cryptomator.jfuse.examples.PosixMirrorFileSystem" />
     <module name="jfuse-examples" />
     <option name="PROGRAM_PARAMETERS" value="$USER_HOME$/Desktop/TMP $USER_HOME$/Desktop/MNT" />
-    <option name="VM_PARAMETERS" value="-Djava.library.path=/usr/local/lib -Dorg.slf4j.simpleLogger.defaultLogLevel=debug --enable-native-access=org.cryptomator.jfuse.mac --enable-preview -Dfuse.lib.path=/usr/local/lib/libfuse-t.dylib" />
+    <option name="VM_PARAMETERS" value="-Djava.library.path=/usr/local/lib -Dorg.slf4j.simpleLogger.defaultLogLevel=debug --enable-native-access=org.cryptomator.jfuse.mac -Dfuse.lib.path=/usr/local/lib/libfuse-t.dylib" />
     <extension name="coverage">
       <pattern>
         <option name="PATTERN" value="de.skymatic.fusepanama.examples.*" />
diff --git a/.idea/runConfigurations/PosixMirrorFileSystem__macFUSE_.xml b/.idea/runConfigurations/PosixMirrorFileSystem__macFUSE_.xml
index 4bd7da00..1a45eab3 100644
--- a/.idea/runConfigurations/PosixMirrorFileSystem__macFUSE_.xml
+++ b/.idea/runConfigurations/PosixMirrorFileSystem__macFUSE_.xml
@@ -3,7 +3,7 @@
     <option name="MAIN_CLASS_NAME" value="org.cryptomator.jfuse.examples.PosixMirrorFileSystem" />
     <module name="jfuse-examples" />
     <option name="PROGRAM_PARAMETERS" value="$USER_HOME$/Desktop/TMP /Volumes/foo" />
-    <option name="VM_PARAMETERS" value="-Djava.library.path=/usr/local/lib -Dorg.slf4j.simpleLogger.defaultLogLevel=debug --enable-native-access=org.cryptomator.jfuse.mac --enable-preview -Dfuse.lib.path=/usr/local/lib/libfuse.dylib" />
+    <option name="VM_PARAMETERS" value="-Djava.library.path=/usr/local/lib -Dorg.slf4j.simpleLogger.defaultLogLevel=debug --enable-native-access=org.cryptomator.jfuse.mac -Dfuse.lib.path=/usr/local/lib/libfuse.dylib" />
     <extension name="coverage">
       <pattern>
         <option name="PATTERN" value="de.skymatic.fusepanama.examples.*" />
diff --git a/.idea/runConfigurations/RandomFileSystem.xml b/.idea/runConfigurations/RandomFileSystem.xml
index 6ebe82bc..317ed1c7 100644
--- a/.idea/runConfigurations/RandomFileSystem.xml
+++ b/.idea/runConfigurations/RandomFileSystem.xml
@@ -3,7 +3,7 @@
     <option name="MAIN_CLASS_NAME" value="org.cryptomator.jfuse.examples.RandomFileSystem" />
     <module name="jfuse-examples" />
     <option name="PROGRAM_PARAMETERS" value="/Volumes/random" />
-    <option name="VM_PARAMETERS" value="-Dorg.slf4j.simpleLogger.defaultLogLevel=debug -Djava.library.path=/usr/local/lib --enable-native-access=org.cryptomator.jfuse.mac --enable-preview" />
+    <option name="VM_PARAMETERS" value="-Dorg.slf4j.simpleLogger.defaultLogLevel=debug -Djava.library.path=/usr/local/lib --enable-native-access=org.cryptomator.jfuse.mac" />
     <extension name="coverage">
       <pattern>
         <option name="PATTERN" value="org.cryptomator.jfuse.examples.*" />
diff --git a/.idea/runConfigurations/WindowsMirrorFileSystem.xml b/.idea/runConfigurations/WindowsMirrorFileSystem.xml
index 80c73e26..fa6ca51c 100644
--- a/.idea/runConfigurations/WindowsMirrorFileSystem.xml
+++ b/.idea/runConfigurations/WindowsMirrorFileSystem.xml
@@ -3,7 +3,7 @@
     <option name="MAIN_CLASS_NAME" value="org.cryptomator.jfuse.examples.WindowsMirrorFileSystem" />
     <module name="jfuse-examples" />
     <option name="PROGRAM_PARAMETERS" value="T:\test M:" />
-    <option name="VM_PARAMETERS" value="-Dorg.slf4j.simpleLogger.defaultLogLevel=info --enable-native-access=org.cryptomator.jfuse.win --enable-preview" />
+    <option name="VM_PARAMETERS" value="-Dorg.slf4j.simpleLogger.defaultLogLevel=info --enable-native-access=org.cryptomator.jfuse.win" />
     <extension name="coverage">
       <pattern>
         <option name="PATTERN" value="de.skymatic.fusepanama.examples.*" />
diff --git a/README.md b/README.md
index b5841ca4..7c90cb64 100644
--- a/README.md
+++ b/README.md
@@ -6,12 +6,12 @@
 
 # jFUSE
 
-Zero-Dependency Java bindings for FUSE using [JEP 442](https://openjdk.org/jeps/442).
+Zero-Dependency Java bindings for FUSE using [JEP 454](https://openjdk.org/jeps/454).
 
 ## Status
 
-This is currently an experimental library requiring JDK 21. As long as the [Foreign Function & Memory API](https://openjdk.org/jeps/442) is incubating, the required JDK will increase.
-Older JDK versions are *not supported*. Please refer to an older version of this lib, if you  are interested in using it with an older JDK. Older versions will not receive patches or any kind of support, though!
+This lib makes use of the [Foreign Function & Memory API](https://openjdk.org/jeps/454), requiring at least JDK 22.
+Older JDK versions are *not supported*. Please refer to an older version of this lib, if you  are interested in using it with an older JDK (with `--enable-preview`). Older versions will not receive patches or any kind of support, though!
 
 We attempt to support libfuse 3.x on Linux and Windows while also remaining compatible with libfuse 2.x on macOS, leading to some compromises in the API.
 
@@ -97,7 +97,6 @@ During runtime, you will need to add allow native access from platform-specific
 java -p path/to/mods \
   -m com.example.mymodule/com.example.mymodule \
   --enable-native-access=org.cryptomator.jfuse.mac \
-  --enable-preview
 ```
 
 ## Supported Platforms
diff --git a/jfuse-api/src/main/java/org/cryptomator/jfuse/api/util/MemoryUtils.java b/jfuse-api/src/main/java/org/cryptomator/jfuse/api/util/MemoryUtils.java
index 100c3b73..ef5027b4 100644
--- a/jfuse-api/src/main/java/org/cryptomator/jfuse/api/util/MemoryUtils.java
+++ b/jfuse-api/src/main/java/org/cryptomator/jfuse/api/util/MemoryUtils.java
@@ -8,7 +8,7 @@ public class MemoryUtils {
 
 	@Nullable
 	public static String toUtf8StringOrNull(MemorySegment string, long offset) {
-		return MemorySegment.NULL.equals(string) ? null : string.getUtf8String(offset);
+		return MemorySegment.NULL.equals(string) ? null : string.getString(offset);
 	}
 
 	@Nullable
diff --git a/jfuse-api/src/test/java/org/cryptomator/jfuse/api/util/MemoryUtilsTest.java b/jfuse-api/src/test/java/org/cryptomator/jfuse/api/util/MemoryUtilsTest.java
index ad4c2ab8..e7bb9920 100644
--- a/jfuse-api/src/test/java/org/cryptomator/jfuse/api/util/MemoryUtilsTest.java
+++ b/jfuse-api/src/test/java/org/cryptomator/jfuse/api/util/MemoryUtilsTest.java
@@ -15,7 +15,7 @@ public class MemoryUtilsTest {
 	void testValidSegmentReturnsString() {
 		try (var arena = Arena.ofConfined()) {
 			var address = arena.allocate(4);
-			address.setUtf8String(0, "abc");
+			address.setString(0, "abc");
 			String result = MemoryUtils.toUtf8StringOrNull(address);
 			Assertions.assertEquals("abc", result);
 		}
@@ -26,7 +26,7 @@ void testValidSegmentReturnsString() {
 	void testValidSegmentReturnsStringAtOffset() {
 		try (var arena = Arena.ofConfined()) {
 			var address = arena.allocate(10);
-			address.setUtf8String(5, "abc");
+			address.setString(5, "abc");
 			String result = MemoryUtils.toUtf8StringOrNull(address, 5);
 			Assertions.assertEquals("abc", result);
 		}
diff --git a/jfuse-examples/README.md b/jfuse-examples/README.md
index b0e17d41..1d5440be 100644
--- a/jfuse-examples/README.md
+++ b/jfuse-examples/README.md
@@ -2,7 +2,7 @@
 
 Assuming you have built the parent project (`mvn package`), you can run these examples directly from the shell.
 
-These examples require JDK 19 or newer. You may want to adjust paths, such as the `java.library.path`.
+These examples require JDK 22 or newer. You may want to adjust paths, such as the `java.library.path`.
 
 ### Running the hello world example:
 
diff --git a/jfuse-linux-aarch64/pom.xml b/jfuse-linux-aarch64/pom.xml
index 05fab908..3ac4503e 100644
--- a/jfuse-linux-aarch64/pom.xml
+++ b/jfuse-linux-aarch64/pom.xml
@@ -31,7 +31,7 @@
 				<groupId>org.apache.maven.plugins</groupId>
 				<artifactId>maven-surefire-plugin</artifactId>
 				<configuration>
-					<argLine>@{surefire.jacoco.args} -javaagent:${net.bytebuddy:byte-buddy-agent:jar} --enable-preview --enable-native-access=org.cryptomator.jfuse.linux.aarch64</argLine>
+					<argLine>@{surefire.jacoco.args} -javaagent:${net.bytebuddy:byte-buddy-agent:jar} --enable-native-access=org.cryptomator.jfuse.linux.aarch64</argLine>
 				</configuration>
 			</plugin>
 		</plugins>
@@ -81,7 +81,7 @@
 					<plugin>
 						<groupId>io.github.coffeelibs</groupId>
 						<artifactId>jextract-maven-plugin</artifactId>
-						<version>0.3.0</version>
+						<version>0.4.0</version>
 						<configuration>
 							<executable>/Users/sebastian/git/github.com/openjdk/jextract/build/jextract/bin/jextract</executable>
 							<headerSearchPaths>${linux.headerSearchPath}</headerSearchPaths>
diff --git a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/DirFillerImpl.java b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/DirFillerImpl.java
index a6388ed3..fb682f94 100644
--- a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/DirFillerImpl.java
+++ b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/DirFillerImpl.java
@@ -9,17 +9,13 @@
 import java.lang.foreign.MemorySegment;
 import java.util.function.Consumer;
 
-record DirFillerImpl(MemorySegment buf, fuse_fill_dir_t callback, Arena arena) implements DirFiller {
-
-	DirFillerImpl(MemorySegment buf, MemorySegment callback, Arena arena) {
-		this(buf, fuse_fill_dir_t.ofAddress(callback, arena), arena);
-	}
+record DirFillerImpl(MemorySegment buf, MemorySegment callback, Arena arena) implements DirFiller {
 
 	@Override
 	public int fill(String name, Consumer<Stat> statFiller, long offset, int flags) {
 		var statSegment = stat.allocate(arena);
 		statFiller.accept(new StatImpl(statSegment));
-		return callback.apply(buf, arena.allocateUtf8String(name), statSegment, offset, flags);
+		return fuse_fill_dir_t.invoke(callback, buf, arena.allocateFrom(name), statSegment, offset, flags);
 	}
 
 }
\ No newline at end of file
diff --git a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/FileInfoImpl.java b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/FileInfoImpl.java
index e3017038..fcb56b13 100644
--- a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/FileInfoImpl.java
+++ b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/FileInfoImpl.java
@@ -5,7 +5,6 @@
 import org.cryptomator.jfuse.linux.aarch64.extr.fuse3.fuse_file_info;
 import org.jetbrains.annotations.Nullable;
 
-import java.lang.foreign.Arena;
 import java.lang.foreign.MemorySegment;
 import java.nio.file.StandardOpenOption;
 import java.util.EnumSet;
@@ -24,34 +23,29 @@ record FileInfoImpl(MemorySegment segment) implements FileInfo {
 	private static final int O_DSYNC = fcntl_h.O_DSYNC();
 
 	/**
-	 * Factory method to map native memory to an {@link FileInfo} object
+	 * Null-safe factory method to map native memory to an {@link FileInfo} object
 	 *
 	 * @param address the {@link MemorySegment} representing the starting address
-	 * @param scope   the {@link Arena} in which this object will be alive
 	 * @return an {@link FileInfo} object or {@code null} if {@code address} is a NULL pointer
 	 */
 	@Nullable
-	public static FileInfoImpl of(MemorySegment address, Arena scope) {
-		return MemorySegment.NULL.equals(address) ? null : new FileInfoImpl(address, scope);
-	}
-
-	public FileInfoImpl(MemorySegment address, Arena scope) {
-		this(fuse_file_info.ofAddress(address, scope));
+	public static FileInfoImpl ofNullable(MemorySegment address) {
+		return MemorySegment.NULL.equals(address) ? null : new FileInfoImpl(address);
 	}
 
 	@Override
 	public long getFh() {
-		return fuse_file_info.fh$get(segment);
+		return fuse_file_info.fh(segment);
 	}
 
 	@Override
 	public void setFh(long fh) {
-		fuse_file_info.fh$set(segment, fh);
+		fuse_file_info.fh(segment, fh);
 	}
 
 	@Override
 	public int getFlags() {
-		return fuse_file_info.flags$get(segment);
+		return fuse_file_info.flags(segment);
 	}
 
 	@Override
@@ -91,7 +85,7 @@ public Set<StandardOpenOption> getOpenFlags() {
 
 	@Override
 	public long getLockOwner() {
-		return fuse_file_info.lock_owner$get(segment);
+		return fuse_file_info.lock_owner(segment);
 	}
 
 }
diff --git a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/FuseArgs.java b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/FuseArgs.java
index d3c1c1ef..7932803c 100644
--- a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/FuseArgs.java
+++ b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/FuseArgs.java
@@ -11,35 +11,35 @@ record FuseArgs(MemorySegment args, MemorySegment cmdLineOpts) {
 	@Override
 	public String toString() {
 		var sb = new StringBuilder();
-		var argc = fuse_args.argc$get(args);
-		var argv = fuse_args.argv$get(args);
+		var argc = fuse_args.argc(args);
+		var argv = fuse_args.argv(args);
 		for (int i = 0; i < argc; i++) {
 			var cString = argv.getAtIndex(ValueLayout.ADDRESS, i).reinterpret(Long.MAX_VALUE);
-			sb.append("arg[").append(i).append("] = ").append(cString.getUtf8String(0)).append(", ");
+			sb.append("arg[").append(i).append("] = ").append(cString.getString(0)).append(", ");
 		}
-		sb.append("mountPoint = ").append(mountPoint().getUtf8String(0));
-		sb.append("debug = ").append(fuse_cmdline_opts.debug$get(cmdLineOpts));
+		sb.append("mountPoint = ").append(mountPoint().getString(0));
+		sb.append("debug = ").append(fuse_cmdline_opts.debug(cmdLineOpts));
 		sb.append("singlethreaded = ").append(!multithreaded());
 		return sb.toString();
 	}
 
 	public MemorySegment mountPoint() {
-		return fuse_cmdline_opts.mountpoint$get(cmdLineOpts);
+		return fuse_cmdline_opts.mountpoint(cmdLineOpts);
 	}
 
 	public boolean multithreaded() {
-		return fuse_cmdline_opts.singlethread$get(cmdLineOpts) == 0;
+		return fuse_cmdline_opts.singlethread(cmdLineOpts) == 0;
 	}
 
 	public int cloneFd() {
-		return fuse_cmdline_opts.clone_fd$get(cmdLineOpts);
+		return fuse_cmdline_opts.clone_fd(cmdLineOpts);
 	}
 
 	public int maxIdleThreads() {
-		return fuse_cmdline_opts.max_idle_threads$get(cmdLineOpts);
+		return fuse_cmdline_opts.max_idle_threads(cmdLineOpts);
 	}
 
 	public int maxThreads() {
-		return fuse_cmdline_opts.max_threads$get(cmdLineOpts);
+		return fuse_cmdline_opts.max_threads(cmdLineOpts);
 	}
 }
diff --git a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/FuseConfigImpl.java b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/FuseConfigImpl.java
index ea8a2e50..66b6b21d 100644
--- a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/FuseConfigImpl.java
+++ b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/FuseConfigImpl.java
@@ -8,118 +8,114 @@
 
 record FuseConfigImpl(MemorySegment segment) implements FuseConfig {
 
-	public FuseConfigImpl(MemorySegment address, Arena scope) {
-		this(fuse_config.ofAddress(address, scope));
-	}
-
 	@Override
 	public int setGid() {
-		return fuse_config.set_gid$get(segment);
+		return fuse_config.set_gid(segment);
 	}
 
 	@Override
 	public int gid() {
-		return fuse_config.gid$get(segment);
+		return fuse_config.gid(segment);
 	}
 
 	@Override
 	public int setUid() {
-		return fuse_config.set_uid$get(segment);
+		return fuse_config.set_uid(segment);
 	}
 
 	@Override
 	public int uid() {
-		return fuse_config.uid$get(segment);
+		return fuse_config.uid(segment);
 	}
 
 	@Override
 	public int setMode() {
-		return fuse_config.set_mode$get(segment);
+		return fuse_config.set_mode(segment);
 	}
 
 	@Override
 	public int umask() {
-		return fuse_config.umask$get(segment);
+		return fuse_config.umask(segment);
 	}
 
 	@Override
 	public double entryTimeout() {
-		return fuse_config.entry_timeout$get(segment);
+		return fuse_config.entry_timeout(segment);
 	}
 
 	@Override
 	public double negativeTimeout() {
-		return fuse_config.negative_timeout$get(segment);
+		return fuse_config.negative_timeout(segment);
 	}
 
 	@Override
 	public double attrTimeout() {
-		return fuse_config.attr_timeout$get(segment);
+		return fuse_config.attr_timeout(segment);
 	}
 
 	@Override
 	public int intr() {
-		return fuse_config.intr$get(segment);
+		return fuse_config.intr(segment);
 	}
 
 	@Override
 	public int intrSignal() {
-		return fuse_config.intr_signal$get(segment);
+		return fuse_config.intr_signal(segment);
 	}
 
 	@Override
 	public int remember() {
-		return fuse_config.remember$get(segment);
+		return fuse_config.remember(segment);
 	}
 
 	@Override
 	public int hardRemove() {
-		return fuse_config.hard_remove$get(segment);
+		return fuse_config.hard_remove(segment);
 	}
 
 	@Override
 	public int useIno() {
-		return fuse_config.use_ino$get(segment);
+		return fuse_config.use_ino(segment);
 	}
 
 	@Override
 	public int readdirIno() {
-		return fuse_config.readdir_ino$get(segment);
+		return fuse_config.readdir_ino(segment);
 	}
 
 	@Override
 	public int directIo() {
-		return fuse_config.direct_io$get(segment);
+		return fuse_config.direct_io(segment);
 	}
 
 	@Override
 	public int kernelCache() {
-		return fuse_config.kernel_cache$get(segment);
+		return fuse_config.kernel_cache(segment);
 	}
 
 	@Override
 	public int autoCache() {
-		return fuse_config.auto_cache$get(segment);
+		return fuse_config.auto_cache(segment);
 	}
 
 	@Override
 	public int acAttrTimeoutSet() {
-		return fuse_config.ac_attr_timeout_set$get(segment);
+		return fuse_config.ac_attr_timeout_set(segment);
 	}
 
 	@Override
 	public double acAttrTimeout() {
-		return fuse_config.ac_attr_timeout$get(segment);
+		return fuse_config.ac_attr_timeout(segment);
 	}
 
 	@Override
 	public int nullpathOk() {
-		return fuse_config.nullpath_ok$get(segment);
+		return fuse_config.nullpath_ok(segment);
 	}
 
 	@Override
 	public int noRofdFlush() {
-		return fuse_config.no_rofd_flush$get(segment);
+		return fuse_config.no_rofd_flush(segment);
 	}
 
 }
diff --git a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/FuseConnInfoImpl.java b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/FuseConnInfoImpl.java
index 6b9f393f..8b20f86d 100644
--- a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/FuseConnInfoImpl.java
+++ b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/FuseConnInfoImpl.java
@@ -8,93 +8,89 @@
 
 record FuseConnInfoImpl(MemorySegment segment) implements FuseConnInfo {
 
-	public FuseConnInfoImpl(MemorySegment address, Arena scope) {
-		this(fuse_conn_info.ofAddress(address, scope));
-	}
-
 	@Override
 	public int protoMajor() {
-		return fuse_conn_info.proto_major$get(segment);
+		return fuse_conn_info.proto_major(segment);
 	}
 
 	@Override
 	public int protoMinor() {
-		return fuse_conn_info.proto_minor$get(segment);
+		return fuse_conn_info.proto_minor(segment);
 	}
 
 	@Override
 	public int capable() {
-		return fuse_conn_info.capable$get(segment);
+		return fuse_conn_info.capable(segment);
 	}
 
 	@Override
 	public int want() {
-		return fuse_conn_info.want$get(segment);
+		return fuse_conn_info.want(segment);
 	}
 
 	@Override
 	public void setWant(int wanted) {
-		fuse_conn_info.want$set(segment, wanted);
+		fuse_conn_info.want(segment, wanted);
 	}
 
 	@Override
 	public int maxWrite() {
-		return fuse_conn_info.max_write$get(segment);
+		return fuse_conn_info.max_write(segment);
 	}
 
 	@Override
 	public void setMaxWrite(int maxWrite) {
-		fuse_conn_info.max_write$set(segment, maxWrite);
+		fuse_conn_info.max_write(segment, maxWrite);
 	}
 
 	@Override
 	public int maxRead() {
-		return fuse_conn_info.max_read$get(segment);
+		return fuse_conn_info.max_read(segment);
 	}
 
 	@Override
 	public void setMaxRead(int maxRead) {
-		fuse_conn_info.max_read$set(segment, maxRead);
+		fuse_conn_info.max_read(segment, maxRead);
 	}
 
 	@Override
 	public int maxReadahead() {
-		return fuse_conn_info.max_readahead$get(segment);
+		return fuse_conn_info.max_readahead(segment);
 	}
 
 	@Override
 	public void setMaxReadahead(int maxReadahead) {
-		fuse_conn_info.max_readahead$set(segment, maxReadahead);
+		fuse_conn_info.max_readahead(segment, maxReadahead);
 	}
 
 	@Override
 	public int maxBackground() {
-		return fuse_conn_info.max_background$get(segment);
+		return fuse_conn_info.max_background(segment);
 	}
 
 	@Override
 	public void setMaxBackground(int maxBackground) {
-		fuse_conn_info.max_background$set(segment, maxBackground);
+		fuse_conn_info.max_background(segment, maxBackground);
 	}
 
 	@Override
 	public int congestionThreshold() {
-		return fuse_conn_info.congestion_threshold$get(segment);
+		return fuse_conn_info.congestion_threshold(segment);
 	}
 
 	@Override
 	public void setCongestionThreshold(int congestionThreshold) {
-		fuse_conn_info.congestion_threshold$set(segment, congestionThreshold);
+		fuse_conn_info.congestion_threshold(segment, congestionThreshold);
 	}
 
 	@Override
 	public int timeGran() {
-		return fuse_conn_info.time_gran$get(segment);
+		return fuse_conn_info.time_gran(segment);
 	}
 
 	@Override
 	public void setTimeGran(int timeGran) {
-		fuse_conn_info.time_gran$set(segment, timeGran);
+		fuse_conn_info.time_gran(segment, timeGran);
 	}
 
 }
diff --git a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/FuseImpl.java b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/FuseImpl.java
index f2a91ace..738dafeb 100644
--- a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/FuseImpl.java
+++ b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/FuseImpl.java
@@ -42,22 +42,22 @@ protected FuseMount mount(List<String> args) throws FuseMountFailedException {
 	FuseArgs parseArgs(List<String> cmdLineArgs) throws IllegalArgumentException {
 		var args = fuse_args.allocate(fuseArena);
 		var argc = cmdLineArgs.size();
-		var argv = fuseArena.allocateArray(ValueLayout.ADDRESS, argc + 1L);
+		var argv = fuseArena.allocate(ValueLayout.ADDRESS, argc + 1L);
 		for (int i = 0; i < argc; i++) {
-			var cString = fuseArena.allocateUtf8String(cmdLineArgs.get(i));
+			var cString = fuseArena.allocateFrom(cmdLineArgs.get(i));
 			argv.setAtIndex(ValueLayout.ADDRESS, i, cString);
 		}
 		argv.setAtIndex(ValueLayout.ADDRESS, argc, MemorySegment.NULL);
-		fuse_args.argc$set(args, argc);
-		fuse_args.argv$set(args, argv);
-		fuse_args.allocated$set(args, 0);
+		fuse_args.argc(args, argc);
+		fuse_args.argv(args, argv);
+		fuse_args.allocated(args, 0);
 
 		var opts = fuse_cmdline_opts.allocate(fuseArena);
 		int parseResult = FuseFunctions.fuse_parse_cmdline(args, opts);
 		if (parseResult != 0) {
 			throw new IllegalArgumentException("fuse_parse_cmdline failed to parse " + String.join(" ", cmdLineArgs));
 		}
-		if (fuse_cmdline_opts.show_help$get(opts) == 1) {
+		if (fuse_cmdline_opts.show_help(opts) == 1) {
 			fuse_h.fuse_lib_help(args);
 			throw new IllegalArgumentException("Flags contained -h or --help. Processing cancelled after printing help");
 		}
@@ -67,71 +67,63 @@ FuseArgs parseArgs(List<String> cmdLineArgs) throws IllegalArgumentException {
 	@Override
 	protected void bind(FuseOperations.Operation operation) {
 		switch (operation) {
-			case INIT -> fuse_operations.init$set(fuseOperationsStruct, fuse_operations.init.allocate(this::init, fuseArena));
-			case ACCESS -> fuse_operations.access$set(fuseOperationsStruct, fuse_operations.access.allocate(this::access, fuseArena));
-			case CHMOD -> fuse_operations.chmod$set(fuseOperationsStruct, fuse_operations.chmod.allocate(this::chmod, fuseArena));
-			case CHOWN -> fuse_operations.chown$set(fuseOperationsStruct, fuse_operations.chown.allocate(this::chown, fuseArena));
-			case CREATE -> fuse_operations.create$set(fuseOperationsStruct, fuse_operations.create.allocate(this::create, fuseArena));
-			case DESTROY -> fuse_operations.destroy$set(fuseOperationsStruct, fuse_operations.destroy.allocate(this::destroy, fuseArena));
-			case FLUSH -> fuse_operations.flush$set(fuseOperationsStruct, fuse_operations.flush.allocate(this::flush, fuseArena));
-			case FSYNC -> fuse_operations.fsync$set(fuseOperationsStruct, fuse_operations.fsync.allocate(this::fsync, fuseArena));
-			case FSYNCDIR -> fuse_operations.fsyncdir$set(fuseOperationsStruct, fuse_operations.fsyncdir.allocate(this::fsyncdir, fuseArena));
-			case GET_ATTR -> fuse_operations.getattr$set(fuseOperationsStruct, fuse_operations.getattr.allocate(this::getattr, fuseArena));
-			case GET_XATTR -> fuse_operations.getxattr$set(fuseOperationsStruct, fuse_operations.getxattr.allocate(this::getxattr, fuseArena));
-			case LIST_XATTR -> fuse_operations.listxattr$set(fuseOperationsStruct, fuse_operations.listxattr.allocate(this::listxattr, fuseArena));
-			case MKDIR -> fuse_operations.mkdir$set(fuseOperationsStruct, fuse_operations.mkdir.allocate(this::mkdir, fuseArena));
-			case OPEN -> fuse_operations.open$set(fuseOperationsStruct, fuse_operations.open.allocate(this::open, fuseArena));
-			case OPEN_DIR -> fuse_operations.opendir$set(fuseOperationsStruct, fuse_operations.opendir.allocate(this::opendir, fuseArena));
-			case READ -> fuse_operations.read$set(fuseOperationsStruct, fuse_operations.read.allocate(this::read, fuseArena));
-			case READ_DIR -> fuse_operations.readdir$set(fuseOperationsStruct, fuse_operations.readdir.allocate(this::readdir, fuseArena));
-			case READLINK -> fuse_operations.readlink$set(fuseOperationsStruct, fuse_operations.readlink.allocate(this::readlink, fuseArena));
-			case RELEASE -> fuse_operations.release$set(fuseOperationsStruct, fuse_operations.release.allocate(this::release, fuseArena));
-			case RELEASE_DIR -> fuse_operations.releasedir$set(fuseOperationsStruct, fuse_operations.releasedir.allocate(this::releasedir, fuseArena));
-			case REMOVE_XATTR -> fuse_operations.removexattr$set(fuseOperationsStruct, fuse_operations.removexattr.allocate(this::removexattr, fuseArena));
-			case RENAME -> fuse_operations.rename$set(fuseOperationsStruct, fuse_operations.rename.allocate(this::rename, fuseArena));
-			case RMDIR -> fuse_operations.rmdir$set(fuseOperationsStruct, fuse_operations.rmdir.allocate(this::rmdir, fuseArena));
-			case SET_XATTR -> fuse_operations.setxattr$set(fuseOperationsStruct, fuse_operations.setxattr.allocate(this::setxattr, fuseArena));
-			case STATFS -> fuse_operations.statfs$set(fuseOperationsStruct, fuse_operations.statfs.allocate(this::statfs, fuseArena));
-			case SYMLINK -> fuse_operations.symlink$set(fuseOperationsStruct, fuse_operations.symlink.allocate(this::symlink, fuseArena));
-			case TRUNCATE -> fuse_operations.truncate$set(fuseOperationsStruct, fuse_operations.truncate.allocate(this::truncate, fuseArena));
-			case UNLINK -> fuse_operations.unlink$set(fuseOperationsStruct, fuse_operations.unlink.allocate(this::unlink, fuseArena));
-			case UTIMENS -> fuse_operations.utimens$set(fuseOperationsStruct, fuse_operations.utimens.allocate(this::utimens, fuseArena));
-			case WRITE -> fuse_operations.write$set(fuseOperationsStruct, fuse_operations.write.allocate(this::write, fuseArena));
+			case INIT -> fuse_operations.init(fuseOperationsStruct, fuse_operations.init.allocate(this::init, fuseArena));
+			case ACCESS -> fuse_operations.access(fuseOperationsStruct, fuse_operations.access.allocate(this::access, fuseArena));
+			case CHMOD -> fuse_operations.chmod(fuseOperationsStruct, fuse_operations.chmod.allocate(this::chmod, fuseArena));
+			case CHOWN -> fuse_operations.chown(fuseOperationsStruct, fuse_operations.chown.allocate(this::chown, fuseArena));
+			case CREATE -> fuse_operations.create(fuseOperationsStruct, fuse_operations.create.allocate(this::create, fuseArena));
+			case DESTROY -> fuse_operations.destroy(fuseOperationsStruct, fuse_operations.destroy.allocate(this::destroy, fuseArena));
+			case FLUSH -> fuse_operations.flush(fuseOperationsStruct, fuse_operations.flush.allocate(this::flush, fuseArena));
+			case FSYNC -> fuse_operations.fsync(fuseOperationsStruct, fuse_operations.fsync.allocate(this::fsync, fuseArena));
+			case FSYNCDIR -> fuse_operations.fsyncdir(fuseOperationsStruct, fuse_operations.fsyncdir.allocate(this::fsyncdir, fuseArena));
+			case GET_ATTR -> fuse_operations.getattr(fuseOperationsStruct, fuse_operations.getattr.allocate(this::getattr, fuseArena));
+			case GET_XATTR -> fuse_operations.getxattr(fuseOperationsStruct, fuse_operations.getxattr.allocate(this::getxattr, fuseArena));
+			case LIST_XATTR -> fuse_operations.listxattr(fuseOperationsStruct, fuse_operations.listxattr.allocate(this::listxattr, fuseArena));
+			case MKDIR -> fuse_operations.mkdir(fuseOperationsStruct, fuse_operations.mkdir.allocate(this::mkdir, fuseArena));
+			case OPEN -> fuse_operations.open(fuseOperationsStruct, fuse_operations.open.allocate(this::open, fuseArena));
+			case OPEN_DIR -> fuse_operations.opendir(fuseOperationsStruct, fuse_operations.opendir.allocate(this::opendir, fuseArena));
+			case READ -> fuse_operations.read(fuseOperationsStruct, fuse_operations.read.allocate(this::read, fuseArena));
+			case READ_DIR -> fuse_operations.readdir(fuseOperationsStruct, fuse_operations.readdir.allocate(this::readdir, fuseArena));
+			case READLINK -> fuse_operations.readlink(fuseOperationsStruct, fuse_operations.readlink.allocate(this::readlink, fuseArena));
+			case RELEASE -> fuse_operations.release(fuseOperationsStruct, fuse_operations.release.allocate(this::release, fuseArena));
+			case RELEASE_DIR -> fuse_operations.releasedir(fuseOperationsStruct, fuse_operations.releasedir.allocate(this::releasedir, fuseArena));
+			case REMOVE_XATTR -> fuse_operations.removexattr(fuseOperationsStruct, fuse_operations.removexattr.allocate(this::removexattr, fuseArena));
+			case RENAME -> fuse_operations.rename(fuseOperationsStruct, fuse_operations.rename.allocate(this::rename, fuseArena));
+			case RMDIR -> fuse_operations.rmdir(fuseOperationsStruct, fuse_operations.rmdir.allocate(this::rmdir, fuseArena));
+			case SET_XATTR -> fuse_operations.setxattr(fuseOperationsStruct, fuse_operations.setxattr.allocate(this::setxattr, fuseArena));
+			case STATFS -> fuse_operations.statfs(fuseOperationsStruct, fuse_operations.statfs.allocate(this::statfs, fuseArena));
+			case SYMLINK -> fuse_operations.symlink(fuseOperationsStruct, fuse_operations.symlink.allocate(this::symlink, fuseArena));
+			case TRUNCATE -> fuse_operations.truncate(fuseOperationsStruct, fuse_operations.truncate.allocate(this::truncate, fuseArena));
+			case UNLINK -> fuse_operations.unlink(fuseOperationsStruct, fuse_operations.unlink.allocate(this::unlink, fuseArena));
+			case UTIMENS -> fuse_operations.utimens(fuseOperationsStruct, fuse_operations.utimens.allocate(this::utimens, fuseArena));
+			case WRITE -> fuse_operations.write(fuseOperationsStruct, fuse_operations.write.allocate(this::write, fuseArena));
 		}
 	}
 
 	@VisibleForTesting
 	MemorySegment init(MemorySegment conn, MemorySegment cfg) {
-		try (var arena = Arena.ofConfined()) {
-			var connInfo = new FuseConnInfoImpl(conn, arena);
-			connInfo.setWant(connInfo.want() | FuseConnInfo.FUSE_CAP_READDIRPLUS);
-			var config = new FuseConfigImpl(cfg, arena);
-			fuseOperations.init(connInfo, config);
-		}
+		var connInfo = new FuseConnInfoImpl(conn);
+		connInfo.setWant(connInfo.want() | FuseConnInfo.FUSE_CAP_READDIRPLUS);
+		var config = new FuseConfigImpl(cfg);
+		fuseOperations.init(connInfo, config);
 		return MemorySegment.NULL;
 	}
 
 	private int access(MemorySegment path, int mask) {
-		return fuseOperations.access(path.getUtf8String(0), mask);
+		return fuseOperations.access(path.getString(0), mask);
 	}
 
 	private int chmod(MemorySegment path, int mode, MemorySegment fi) {
-		try (var arena = Arena.ofConfined()) {
-			return fuseOperations.chmod(path.getUtf8String(0), mode, FileInfoImpl.of(fi, arena));
-		}
+		return fuseOperations.chmod(path.getString(0), mode, FileInfoImpl.ofNullable(fi));
 	}
 
 	@VisibleForTesting
 	int chown(MemorySegment path, int uid, int gid, MemorySegment fi) {
-		try (var arena = Arena.ofConfined()) {
-			return fuseOperations.chown(path.getUtf8String(0), uid, gid, FileInfoImpl.of(fi, arena));
-		}
+		return fuseOperations.chown(path.getString(0), uid, gid, FileInfoImpl.ofNullable(fi));
 	}
 
 	private int create(MemorySegment path, int mode, MemorySegment fi) {
-		try (var arena = Arena.ofConfined()) {
-			return fuseOperations.create(path.getUtf8String(0), mode, new FileInfoImpl(fi, arena));
-		}
+		return fuseOperations.create(path.getString(0), mode, new FileInfoImpl(fi));
 	}
 
 	private void destroy(MemorySegment addr) {
@@ -140,127 +132,106 @@ private void destroy(MemorySegment addr) {
 
 	@VisibleForTesting
 	int flush(MemorySegment path, MemorySegment fi) {
-		try (var arena = Arena.ofConfined()) {
-			return fuseOperations.flush(path.getUtf8String(0), new FileInfoImpl(fi, arena));
-		}
+		return fuseOperations.flush(path.getString(0), new FileInfoImpl(fi));
 	}
 
 	@VisibleForTesting
 	int fsync(MemorySegment path, int datasync, MemorySegment fi) {
-		try (var arena = Arena.ofConfined()) {
-			return fuseOperations.fsync(path.getUtf8String(0), datasync, new FileInfoImpl(fi, arena));
-		}
+		return fuseOperations.fsync(path.getString(0), datasync, new FileInfoImpl(fi));
 	}
 
 	@VisibleForTesting
 	int fsyncdir(MemorySegment path, int datasync, MemorySegment fi) {
-		try (var arena = Arena.ofConfined()) {
-			return fuseOperations.fsyncdir(MemoryUtils.toUtf8StringOrNull(path), datasync, new FileInfoImpl(fi, arena));
-		}
+		return fuseOperations.fsyncdir(MemoryUtils.toUtf8StringOrNull(path), datasync, new FileInfoImpl(fi));
 	}
 
 	private int getattr(MemorySegment path, MemorySegment stat, MemorySegment fi) {
-		try (var arena = Arena.ofConfined()) {
-			return fuseOperations.getattr(path.getUtf8String(0), new StatImpl(stat, arena), FileInfoImpl.of(fi, arena));
-		}
+		return fuseOperations.getattr(path.getString(0), new StatImpl(stat), FileInfoImpl.ofNullable(fi));
 	}
 
 	@VisibleForTesting
 	int getxattr(MemorySegment path, MemorySegment name, MemorySegment value, long size) {
 		var val = value.reinterpret(size).asByteBuffer();
-		return fuseOperations.getxattr(path.getUtf8String(0), name.getUtf8String(0), val);
+		return fuseOperations.getxattr(path.getString(0), name.getString(0), val);
 	}
 
 	@VisibleForTesting
 	int setxattr(MemorySegment path, MemorySegment name, MemorySegment value, long size, int flags) {
 		var val = value.reinterpret(size).asByteBuffer();
-		return fuseOperations.setxattr(path.getUtf8String(0), name.getUtf8String(0), val, flags);
+		return fuseOperations.setxattr(path.getString(0), name.getString(0), val, flags);
 	}
 
 	@VisibleForTesting
 	int listxattr(MemorySegment path, MemorySegment value, long size) {
 		var val = value.reinterpret(size).asByteBuffer();
-		return fuseOperations.listxattr(path.getUtf8String(0), val);
+		return fuseOperations.listxattr(path.getString(0), val);
 	}
 
 	@VisibleForTesting
 	int removexattr(MemorySegment path, MemorySegment name) {
-		return fuseOperations.removexattr(path.getUtf8String(0), name.getUtf8String(0));
+		return fuseOperations.removexattr(path.getString(0), name.getString(0));
 	}
 
 	private int mkdir(MemorySegment path, int mode) {
-		return fuseOperations.mkdir(path.getUtf8String(0), mode);
+		return fuseOperations.mkdir(path.getString(0), mode);
 	}
 
 	private int open(MemorySegment path, MemorySegment fi) {
-		try (var arena = Arena.ofConfined()) {
-			return fuseOperations.open(path.getUtf8String(0), new FileInfoImpl(fi, arena));
-		}
+		return fuseOperations.open(path.getString(0), new FileInfoImpl(fi));
 	}
 
 	private int opendir(MemorySegment path, MemorySegment fi) {
-		try (var arena = Arena.ofConfined()) {
-			return fuseOperations.opendir(path.getUtf8String(0), new FileInfoImpl(fi, arena));
-		}
+		return fuseOperations.opendir(path.getString(0), new FileInfoImpl(fi));
 	}
 
 	private int read(MemorySegment path, MemorySegment buf, long size, long offset, MemorySegment fi) {
-		try (var arena = Arena.ofConfined()) {
-			var buffer = buf.reinterpret(size).asByteBuffer();
-			return fuseOperations.read(path.getUtf8String(0), buffer, size, offset, new FileInfoImpl(fi, arena));
-		}
+		var buffer = buf.reinterpret(size).asByteBuffer();
+		return fuseOperations.read(path.getString(0), buffer, size, offset, new FileInfoImpl(fi));
 	}
 
 	private int readdir(MemorySegment path, MemorySegment buf, MemorySegment filler, long offset, MemorySegment fi, int flags) {
 		try (var arena = Arena.ofConfined()) {
-			return fuseOperations.readdir(path.getUtf8String(0), new DirFillerImpl(buf, filler, arena), offset, new FileInfoImpl(fi, arena), flags);
+			return fuseOperations.readdir(path.getString(0), new DirFillerImpl(buf, filler, arena), offset, new FileInfoImpl(fi), flags);
 		}
 	}
 
 	private int readlink(MemorySegment path, MemorySegment buf, long len) {
 		var buffer = buf.reinterpret(len).asByteBuffer();
-		return fuseOperations.readlink(path.getUtf8String(0), buffer, len);
+		return fuseOperations.readlink(path.getString(0), buffer, len);
 	}
 
 	private int release(MemorySegment path, MemorySegment fi) {
-		try (var arena = Arena.ofConfined()) {
-			return fuseOperations.release(path.getUtf8String(0), new FileInfoImpl(fi, arena));
-		}
+		return fuseOperations.release(path.getString(0), new FileInfoImpl(fi));
+
 	}
 
 	private int releasedir(MemorySegment path, MemorySegment fi) {
-		try (var arena = Arena.ofConfined()) {
-			return fuseOperations.releasedir(MemoryUtils.toUtf8StringOrNull(path), new FileInfoImpl(fi, arena));
-		}
+		return fuseOperations.releasedir(MemoryUtils.toUtf8StringOrNull(path), new FileInfoImpl(fi));
 	}
 
 	private int rename(MemorySegment oldpath, MemorySegment newpath, int flags) {
-		return fuseOperations.rename(oldpath.getUtf8String(0), newpath.getUtf8String(0), flags);
+		return fuseOperations.rename(oldpath.getString(0), newpath.getString(0), flags);
 	}
 
 	private int rmdir(MemorySegment path) {
-		return fuseOperations.rmdir(path.getUtf8String(0));
+		return fuseOperations.rmdir(path.getString(0));
 	}
 
 	private int statfs(MemorySegment path, MemorySegment statvfs) {
-		try (var arena = Arena.ofConfined()) {
-			return fuseOperations.statfs(path.getUtf8String(0), new StatvfsImpl(statvfs, arena));
-		}
+		return fuseOperations.statfs(path.getString(0), new StatvfsImpl(statvfs));
 	}
 
 	private int symlink(MemorySegment linkname, MemorySegment target) {
-		return fuseOperations.symlink(linkname.getUtf8String(0), target.getUtf8String(0));
+		return fuseOperations.symlink(linkname.getString(0), target.getString(0));
 	}
 
 	private int truncate(MemorySegment path, long size, MemorySegment fi) {
-		try (var arena = Arena.ofConfined()) {
-			return fuseOperations.truncate(path.getUtf8String(0), size, FileInfoImpl.of(fi, arena));
-		}
+		return fuseOperations.truncate(path.getString(0), size, FileInfoImpl.ofNullable(fi));
 	}
 
 
 	private int unlink(MemorySegment path) {
-		return fuseOperations.unlink(path.getUtf8String(0));
+		return fuseOperations.unlink(path.getString(0));
 	}
 
 	@VisibleForTesting
@@ -268,24 +239,22 @@ int utimens(MemorySegment path, MemorySegment times, MemorySegment fi) {
 		try (var arena = Arena.ofConfined()) {
 			if (MemorySegment.NULL.equals(times)) {
 				// set both times to current time
-				var segment = arena.allocate(timespec.$LAYOUT());
-				timespec.tv_sec$set(segment, 0);
-				timespec.tv_nsec$set(segment, stat_h.UTIME_NOW());
+				var segment = timespec.allocate(arena);
+				timespec.tv_sec(segment, 0);
+				timespec.tv_nsec(segment, stat_h.UTIME_NOW());
 				var time = new TimeSpecImpl(segment);
-				return fuseOperations.utimens(path.getUtf8String(0), time, time, FileInfoImpl.of(fi, arena));
+				return fuseOperations.utimens(path.getString(0), time, time, FileInfoImpl.ofNullable(fi));
 			} else {
-				var time0 = times.asSlice(0, timespec.$LAYOUT().byteSize());
-				var time1 = times.asSlice(timespec.$LAYOUT().byteSize(), timespec.$LAYOUT().byteSize());
-				return fuseOperations.utimens(path.getUtf8String(0), new TimeSpecImpl(time0), new TimeSpecImpl(time1), FileInfoImpl.of(fi, arena));
+				var time0 = timespec.asSlice(times, 0);
+				var time1 = timespec.asSlice(times, 1);
+				return fuseOperations.utimens(path.getString(0), new TimeSpecImpl(time0), new TimeSpecImpl(time1), FileInfoImpl.ofNullable(fi));
 			}
 		}
 	}
 
 	private int write(MemorySegment path, MemorySegment buf, long size, long offset, MemorySegment fi) {
-		try (var arena = Arena.ofConfined()) {
-			var buffer = buf.reinterpret(size).asByteBuffer();
-			return fuseOperations.write(path.getUtf8String(0), buffer, size, offset, new FileInfoImpl(fi, arena));
-		}
+		var buffer = buf.reinterpret(size).asByteBuffer();
+		return fuseOperations.write(path.getString(0), buffer, size, offset, new FileInfoImpl(fi));
 	}
 
 }
diff --git a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/FuseMountImpl.java b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/FuseMountImpl.java
index 4e485909..d004725b 100644
--- a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/FuseMountImpl.java
+++ b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/FuseMountImpl.java
@@ -22,8 +22,8 @@ public int loop() {
 			// FUSE 3.2
 			try (var arena = Arena.ofConfined()) {
 				var loopCfg = fuse_loop_config_v1.allocate(arena);
-				fuse_loop_config_v1.clone_fd$set(loopCfg, fuseArgs.cloneFd());
-				fuse_loop_config_v1.max_idle_threads$set(loopCfg, fuseArgs.maxIdleThreads());
+				fuse_loop_config_v1.clone_fd(loopCfg, fuseArgs.cloneFd());
+				fuse_loop_config_v1.max_idle_threads(loopCfg, fuseArgs.maxIdleThreads());
 				return fuse_h.fuse_loop_mt(fuse, loopCfg);
 			}
 		} else {
diff --git a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/StatImpl.java b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/StatImpl.java
index 885b9650..a2647f36 100644
--- a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/StatImpl.java
+++ b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/StatImpl.java
@@ -9,79 +9,74 @@
 import java.lang.foreign.MemorySegment;
 
 record StatImpl(MemorySegment segment) implements Stat {
-
-	public StatImpl(MemorySegment address, Arena scope) {
-		this(stat.ofAddress(address, scope));
-	}
-
 	@Override
 	public TimeSpec aTime() {
-		return new TimeSpecImpl(stat.st_atim$slice(segment));
+		return new TimeSpecImpl(stat.st_atim(segment));
 	}
 
 	@Override
 	public TimeSpec cTime() {
-		return new TimeSpecImpl(stat.st_ctim$slice(segment));
+		return new TimeSpecImpl(stat.st_ctim(segment));
 	}
 
 	@Override
 	public TimeSpec mTime() {
-		return new TimeSpecImpl(stat.st_mtim$slice(segment));
+		return new TimeSpecImpl(stat.st_mtim(segment));
 	}
 
 	@Override
 	public TimeSpec birthTime() {
-		return new TimeSpecImpl(stat.st_ctim$slice(segment));
+		return new TimeSpecImpl(stat.st_ctim(segment));
 	}
 
 	@Override
 	public void setMode(int mode) {
-		stat.st_mode$set(segment, mode);
+		stat.st_mode(segment, mode);
 	}
 
 	@Override
 	public int getMode() {
-		return stat.st_mode$get(segment);
+		return stat.st_mode(segment);
 	}
 
 	@Override
 	public void setUid(int uid) {
-		stat.st_uid$set(segment, uid);
+		stat.st_uid(segment, uid);
 	}
 
 	@Override
 	public int getUid() {
-		return stat.st_uid$get(segment);
+		return stat.st_uid(segment);
 	}
 
 	@Override
 	public void setGid(int gid) {
-		stat.st_gid$set(segment, gid);
+		stat.st_gid(segment, gid);
 	}
 
 	@Override
 	public int getGid() {
-		return stat.st_gid$get(segment);
+		return stat.st_gid(segment);
 	}
 
 	@Override
 	public void setNLink(short count) {
-		stat.st_nlink$set(segment, count);
+		stat.st_nlink(segment, count);
 	}
 
 	@Override
 	public long getNLink() {
-		return stat.st_nlink$get(segment);
+		return stat.st_nlink(segment);
 	}
 
 	@Override
 	public void setSize(long size) {
-		stat.st_size$set(segment, size);
+		stat.st_size(segment, size);
 	}
 
 	@Override
 	public long getSize() {
-		return stat.st_size$get(segment);
+		return stat.st_size(segment);
 	}
 
 }
diff --git a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/StatvfsImpl.java b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/StatvfsImpl.java
index 7e6f1997..b8163af5 100644
--- a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/StatvfsImpl.java
+++ b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/StatvfsImpl.java
@@ -8,68 +8,64 @@
 
 record StatvfsImpl(MemorySegment segment) implements Statvfs {
 
-	public StatvfsImpl(MemorySegment address, Arena scope) {
-		this(statvfs.ofAddress(address, scope));
-	}
-
 	@Override
 	public long getBsize() {
-		return statvfs.f_bsize$get(segment);
+		return statvfs.f_bsize(segment);
 	}
 
 	@Override
 	public void setBsize(long bsize) {
-		statvfs.f_bsize$set(segment, bsize);
+		statvfs.f_bsize(segment, bsize);
 	}
 
 	@Override
 	public long getFrsize() {
-		return statvfs.f_frsize$get(segment);
+		return statvfs.f_frsize(segment);
 	}
 
 	@Override
 	public void setFrsize(long frsize) {
-		statvfs.f_frsize$set(segment, frsize);
+		statvfs.f_frsize(segment, frsize);
 	}
 
 	@Override
 	public long getBlocks() {
-		return statvfs.f_blocks$get(segment);
+		return statvfs.f_blocks(segment);
 	}
 
 	@Override
 	public void setBlocks(long blocks) {
-		statvfs.f_blocks$set(segment, blocks);
+		statvfs.f_blocks(segment, blocks);
 	}
 
 	@Override
 	public long getBfree() {
-		return statvfs.f_bfree$get(segment);
+		return statvfs.f_bfree(segment);
 	}
 
 	@Override
 	public void setBfree(long bfree) {
-		statvfs.f_bfree$set(segment, bfree);
+		statvfs.f_bfree(segment, bfree);
 	}
 
 	@Override
 	public long getBavail() {
-		return statvfs.f_bavail$get(segment);
+		return statvfs.f_bavail(segment);
 	}
 
 	@Override
 	public void setBavail(long bavail) {
-		statvfs.f_bavail$set(segment, bavail);
+		statvfs.f_bavail(segment, bavail);
 	}
 
 	@Override
 	public long getNameMax() {
-		return statvfs.f_namemax$get(segment);
+		return statvfs.f_namemax(segment);
 	}
 
 	@Override
 	public void setNameMax(long namemax) {
-		statvfs.f_namemax$set(segment, namemax);
+		statvfs.f_namemax(segment, namemax);
 	}
 
 }
diff --git a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/TimeSpecImpl.java b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/TimeSpecImpl.java
index ddd72f6d..51d54609 100644
--- a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/TimeSpecImpl.java
+++ b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/TimeSpecImpl.java
@@ -11,26 +11,26 @@ record TimeSpecImpl(MemorySegment segment) implements TimeSpec {
 
 	@Override
 	public boolean isUtimeOmit() {
-		var nanos = timespec.tv_nsec$get(segment);
+		var nanos = timespec.tv_nsec(segment);
 		return stat_h.UTIME_OMIT() == nanos;
 	}
 
 	@Override
 	public boolean isUtimeNow() {
-		var nanos = timespec.tv_nsec$get(segment);
+		var nanos = timespec.tv_nsec(segment);
 		return stat_h.UTIME_NOW() == nanos;
 	}
 
 	@Override
 	public void set(Instant newValue) {
-		timespec.tv_sec$set(segment, newValue.getEpochSecond());
-		timespec.tv_nsec$set(segment, newValue.getNano());
+		timespec.tv_sec(segment, newValue.getEpochSecond());
+		timespec.tv_nsec(segment, newValue.getNano());
 	}
 
 	@Override
 	public Instant get() {
-		var seconds = timespec.tv_sec$get(segment);
-		var nanos = timespec.tv_nsec$get(segment);
+		var seconds = timespec.tv_sec(segment);
+		var nanos = timespec.tv_nsec(segment);
 		return Instant.ofEpochSecond(seconds, nanos);
 	}
 
diff --git a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/errno/RuntimeHelper.java b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/errno/RuntimeHelper.java
deleted file mode 100644
index f2a17a5f..00000000
--- a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/errno/RuntimeHelper.java
+++ /dev/null
@@ -1,245 +0,0 @@
-package org.cryptomator.jfuse.linux.aarch64.extr.errno;
-// Generated by jextract
-
-import java.lang.foreign.Linker;
-import java.lang.foreign.FunctionDescriptor;
-import java.lang.foreign.GroupLayout;
-import java.lang.foreign.SymbolLookup;
-import java.lang.foreign.MemoryLayout;
-import java.lang.foreign.MemorySegment;
-import java.lang.foreign.Arena;
-import java.lang.foreign.SegmentAllocator;
-import java.lang.foreign.ValueLayout;
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.MethodHandles;
-import java.lang.invoke.MethodType;
-import java.io.File;
-import java.nio.file.Path;
-import java.nio.charset.StandardCharsets;
-import java.util.Arrays;
-import java.util.Optional;
-import java.util.stream.Stream;
-
-import java.lang.foreign.AddressLayout;
-import java.lang.foreign.MemoryLayout;
-
-import static java.lang.foreign.Linker.*;
-import static java.lang.foreign.ValueLayout.*;
-
-final class RuntimeHelper {
-
-    private static final Linker LINKER = Linker.nativeLinker();
-    private static final ClassLoader LOADER = RuntimeHelper.class.getClassLoader();
-    private static final MethodHandles.Lookup MH_LOOKUP = MethodHandles.lookup();
-    private static final SymbolLookup SYMBOL_LOOKUP;
-    private static final SegmentAllocator THROWING_ALLOCATOR = (x, y) -> { throw new AssertionError("should not reach here"); };
-    static final AddressLayout POINTER = ValueLayout.ADDRESS.withTargetLayout(MemoryLayout.sequenceLayout(JAVA_BYTE));
-
-    final static SegmentAllocator CONSTANT_ALLOCATOR =
-            (size, align) -> Arena.ofAuto().allocate(size, align);
-
-    static {
-        
-        SymbolLookup loaderLookup = SymbolLookup.loaderLookup();
-        SYMBOL_LOOKUP = name -> loaderLookup.find(name).or(() -> LINKER.defaultLookup().find(name));
-    }
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private RuntimeHelper() {}
-
-    static <T> T requireNonNull(T obj, String symbolName) {
-        if (obj == null) {
-            throw new UnsatisfiedLinkError("unresolved symbol: " + symbolName);
-        }
-        return obj;
-    }
-
-    static MemorySegment lookupGlobalVariable(String name, MemoryLayout layout) {
-        return SYMBOL_LOOKUP.find(name)
-                .map(s -> s.reinterpret(layout.byteSize()))
-                .orElse(null);
-    }
-
-    static MethodHandle downcallHandle(String name, FunctionDescriptor fdesc) {
-        return SYMBOL_LOOKUP.find(name).
-                map(addr -> LINKER.downcallHandle(addr, fdesc)).
-                orElse(null);
-    }
-
-    static MethodHandle downcallHandle(FunctionDescriptor fdesc) {
-        return LINKER.downcallHandle(fdesc);
-    }
-
-    static MethodHandle downcallHandleVariadic(String name, FunctionDescriptor fdesc) {
-        return SYMBOL_LOOKUP.find(name).
-                map(addr -> VarargsInvoker.make(addr, fdesc)).
-                orElse(null);
-    }
-
-    static MethodHandle upcallHandle(Class<?> fi, String name, FunctionDescriptor fdesc) {
-        try {
-            return MH_LOOKUP.findVirtual(fi, name, fdesc.toMethodType());
-        } catch (Throwable ex) {
-            throw new AssertionError(ex);
-        }
-    }
-
-    static <Z> MemorySegment upcallStub(MethodHandle fiHandle, Z z, FunctionDescriptor fdesc, Arena scope) {
-        try {
-            fiHandle = fiHandle.bindTo(z);
-            return LINKER.upcallStub(fiHandle, fdesc, scope);
-        } catch (Throwable ex) {
-            throw new AssertionError(ex);
-        }
-    }
-
-    static MemorySegment asArray(MemorySegment addr, MemoryLayout layout, int numElements, Arena arena) {
-         return addr.reinterpret(numElements * layout.byteSize(), arena, null);
-    }
-
-    // Internals only below this point
-
-    private static final class VarargsInvoker {
-        private static final MethodHandle INVOKE_MH;
-        private final MemorySegment symbol;
-        private final FunctionDescriptor function;
-
-        private VarargsInvoker(MemorySegment symbol, FunctionDescriptor function) {
-            this.symbol = symbol;
-            this.function = function;
-        }
-
-        static {
-            try {
-                INVOKE_MH = MethodHandles.lookup().findVirtual(VarargsInvoker.class, "invoke", MethodType.methodType(Object.class, SegmentAllocator.class, Object[].class));
-            } catch (ReflectiveOperationException e) {
-                throw new RuntimeException(e);
-            }
-        }
-
-        static MethodHandle make(MemorySegment symbol, FunctionDescriptor function) {
-            VarargsInvoker invoker = new VarargsInvoker(symbol, function);
-            MethodHandle handle = INVOKE_MH.bindTo(invoker).asCollector(Object[].class, function.argumentLayouts().size() + 1);
-            MethodType mtype = MethodType.methodType(function.returnLayout().isPresent() ? carrier(function.returnLayout().get(), true) : void.class);
-            for (MemoryLayout layout : function.argumentLayouts()) {
-                mtype = mtype.appendParameterTypes(carrier(layout, false));
-            }
-            mtype = mtype.appendParameterTypes(Object[].class);
-            boolean needsAllocator = function.returnLayout().isPresent() &&
-                                function.returnLayout().get() instanceof GroupLayout;
-            if (needsAllocator) {
-                mtype = mtype.insertParameterTypes(0, SegmentAllocator.class);
-            } else {
-                handle = MethodHandles.insertArguments(handle, 0, THROWING_ALLOCATOR);
-            }
-            return handle.asType(mtype);
-        }
-
-        static Class<?> carrier(MemoryLayout layout, boolean ret) {
-            if (layout instanceof ValueLayout valueLayout) {
-                return valueLayout.carrier();
-            } else if (layout instanceof GroupLayout) {
-                return MemorySegment.class;
-            } else {
-                throw new AssertionError("Cannot get here!");
-            }
-        }
-
-        private Object invoke(SegmentAllocator allocator, Object[] args) throws Throwable {
-            // one trailing Object[]
-            int nNamedArgs = function.argumentLayouts().size();
-            assert(args.length == nNamedArgs + 1);
-            // The last argument is the array of vararg collector
-            Object[] unnamedArgs = (Object[]) args[args.length - 1];
-
-            int argsCount = nNamedArgs + unnamedArgs.length;
-            Class<?>[] argTypes = new Class<?>[argsCount];
-            MemoryLayout[] argLayouts = new MemoryLayout[nNamedArgs + unnamedArgs.length];
-
-            int pos = 0;
-            for (pos = 0; pos < nNamedArgs; pos++) {
-                argLayouts[pos] = function.argumentLayouts().get(pos);
-            }
-
-            assert pos == nNamedArgs;
-            for (Object o: unnamedArgs) {
-                argLayouts[pos] = variadicLayout(normalize(o.getClass()));
-                pos++;
-            }
-            assert pos == argsCount;
-
-            FunctionDescriptor f = (function.returnLayout().isEmpty()) ?
-                    FunctionDescriptor.ofVoid(argLayouts) :
-                    FunctionDescriptor.of(function.returnLayout().get(), argLayouts);
-            MethodHandle mh = LINKER.downcallHandle(symbol, f);
-            boolean needsAllocator = function.returnLayout().isPresent() &&
-                                            function.returnLayout().get() instanceof GroupLayout;
-            if (needsAllocator) {
-                mh = mh.bindTo(allocator);
-            }
-            // flatten argument list so that it can be passed to an asSpreader MH
-            Object[] allArgs = new Object[nNamedArgs + unnamedArgs.length];
-            System.arraycopy(args, 0, allArgs, 0, nNamedArgs);
-            System.arraycopy(unnamedArgs, 0, allArgs, nNamedArgs, unnamedArgs.length);
-
-            return mh.asSpreader(Object[].class, argsCount).invoke(allArgs);
-        }
-
-        private static Class<?> unboxIfNeeded(Class<?> clazz) {
-            if (clazz == Boolean.class) {
-                return boolean.class;
-            } else if (clazz == Void.class) {
-                return void.class;
-            } else if (clazz == Byte.class) {
-                return byte.class;
-            } else if (clazz == Character.class) {
-                return char.class;
-            } else if (clazz == Short.class) {
-                return short.class;
-            } else if (clazz == Integer.class) {
-                return int.class;
-            } else if (clazz == Long.class) {
-                return long.class;
-            } else if (clazz == Float.class) {
-                return float.class;
-            } else if (clazz == Double.class) {
-                return double.class;
-            } else {
-                return clazz;
-            }
-        }
-
-        private Class<?> promote(Class<?> c) {
-            if (c == byte.class || c == char.class || c == short.class || c == int.class) {
-                return long.class;
-            } else if (c == float.class) {
-                return double.class;
-            } else {
-                return c;
-            }
-        }
-
-        private Class<?> normalize(Class<?> c) {
-            c = unboxIfNeeded(c);
-            if (c.isPrimitive()) {
-                return promote(c);
-            }
-            if (c == MemorySegment.class) {
-                return MemorySegment.class;
-            }
-            throw new IllegalArgumentException("Invalid type for ABI: " + c.getTypeName());
-        }
-
-        private MemoryLayout variadicLayout(Class<?> c) {
-            if (c == long.class) {
-                return JAVA_LONG;
-            } else if (c == double.class) {
-                return JAVA_DOUBLE;
-            } else if (c == MemorySegment.class) {
-                return ADDRESS;
-            } else {
-                throw new IllegalArgumentException("Unhandled variadic argument class: " + c);
-            }
-        }
-    }
-}
diff --git a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/errno/constants$0.java b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/errno/constants$0.java
deleted file mode 100644
index 1b6e78d3..00000000
--- a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/errno/constants$0.java
+++ /dev/null
@@ -1,16 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.linux.aarch64.extr.errno;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$0 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$0() {}
-}
-
-
diff --git a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/errno/errno_h.java b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/errno/errno_h.java
index 2de21eb2..58a7701f 100644
--- a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/errno/errno_h.java
+++ b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/errno/errno_h.java
@@ -2,165 +2,233 @@
 
 package org.cryptomator.jfuse.linux.aarch64.extr.errno;
 
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
+import java.lang.invoke.*;
 import java.lang.foreign.*;
+import java.nio.ByteOrder;
+import java.util.*;
+import java.util.function.*;
+import java.util.stream.*;
+
 import static java.lang.foreign.ValueLayout.*;
-public class errno_h  {
+import static java.lang.foreign.MemoryLayout.PathElement.*;
+
+public class errno_h {
+
+    errno_h() {
+        // Should not be called directly
+    }
+
+    static final Arena LIBRARY_ARENA = Arena.ofAuto();
+    static final boolean TRACE_DOWNCALLS = Boolean.getBoolean("jextract.trace.downcalls");
+
+    static void traceDowncall(String name, Object... args) {
+         String traceArgs = Arrays.stream(args)
+                       .map(Object::toString)
+                       .collect(Collectors.joining(", "));
+         System.out.printf("%s(%s)\n", name, traceArgs);
+    }
 
-    public static final OfByte C_CHAR = JAVA_BYTE;
-    public static final OfShort C_SHORT = JAVA_SHORT;
-    public static final OfInt C_INT = JAVA_INT;
-    public static final OfLong C_LONG = JAVA_LONG;
-    public static final OfLong C_LONG_LONG = JAVA_LONG;
-    public static final OfFloat C_FLOAT = JAVA_FLOAT;
-    public static final OfDouble C_DOUBLE = JAVA_DOUBLE;
-    public static final AddressLayout C_POINTER = RuntimeHelper.POINTER;
-    /**
-     * {@snippet :
+    static MemorySegment findOrThrow(String symbol) {
+        return SYMBOL_LOOKUP.find(symbol)
+            .orElseThrow(() -> new UnsatisfiedLinkError("unresolved symbol: " + symbol));
+    }
+
+    static MethodHandle upcallHandle(Class<?> fi, String name, FunctionDescriptor fdesc) {
+        try {
+            return MethodHandles.lookup().findVirtual(fi, name, fdesc.toMethodType());
+        } catch (ReflectiveOperationException ex) {
+            throw new AssertionError(ex);
+        }
+    }
+
+    static MemoryLayout align(MemoryLayout layout, long align) {
+        return switch (layout) {
+            case PaddingLayout p -> p;
+            case ValueLayout v -> v.withByteAlignment(align);
+            case GroupLayout g -> {
+                MemoryLayout[] alignedMembers = g.memberLayouts().stream()
+                        .map(m -> align(m, align)).toArray(MemoryLayout[]::new);
+                yield g instanceof StructLayout ?
+                        MemoryLayout.structLayout(alignedMembers) : MemoryLayout.unionLayout(alignedMembers);
+            }
+            case SequenceLayout s -> MemoryLayout.sequenceLayout(s.elementCount(), align(s.elementLayout(), align));
+        };
+    }
+
+    static final SymbolLookup SYMBOL_LOOKUP = SymbolLookup.loaderLookup()
+            .or(Linker.nativeLinker().defaultLookup());
+
+    public static final ValueLayout.OfBoolean C_BOOL = ValueLayout.JAVA_BOOLEAN;
+    public static final ValueLayout.OfByte C_CHAR = ValueLayout.JAVA_BYTE;
+    public static final ValueLayout.OfShort C_SHORT = ValueLayout.JAVA_SHORT;
+    public static final ValueLayout.OfInt C_INT = ValueLayout.JAVA_INT;
+    public static final ValueLayout.OfLong C_LONG_LONG = ValueLayout.JAVA_LONG;
+    public static final ValueLayout.OfFloat C_FLOAT = ValueLayout.JAVA_FLOAT;
+    public static final ValueLayout.OfDouble C_DOUBLE = ValueLayout.JAVA_DOUBLE;
+    public static final AddressLayout C_POINTER = ValueLayout.ADDRESS
+            .withTargetLayout(MemoryLayout.sequenceLayout(java.lang.Long.MAX_VALUE, JAVA_BYTE));
+    public static final ValueLayout.OfLong C_LONG = ValueLayout.JAVA_LONG;
+    private static final int ENOENT = (int)2L;
+    /**
+     * {@snippet lang=c :
      * #define ENOENT 2
      * }
      */
     public static int ENOENT() {
-        return (int)2L;
+        return ENOENT;
     }
+    private static final int EIO = (int)5L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define EIO 5
      * }
      */
     public static int EIO() {
-        return (int)5L;
+        return EIO;
     }
+    private static final int E2BIG = (int)7L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define E2BIG 7
      * }
      */
     public static int E2BIG() {
-        return (int)7L;
+        return E2BIG;
     }
+    private static final int EBADF = (int)9L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define EBADF 9
      * }
      */
     public static int EBADF() {
-        return (int)9L;
+        return EBADF;
     }
+    private static final int ENOMEM = (int)12L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define ENOMEM 12
      * }
      */
     public static int ENOMEM() {
-        return (int)12L;
+        return ENOMEM;
     }
+    private static final int EACCES = (int)13L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define EACCES 13
      * }
      */
     public static int EACCES() {
-        return (int)13L;
+        return EACCES;
     }
+    private static final int EEXIST = (int)17L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define EEXIST 17
      * }
      */
     public static int EEXIST() {
-        return (int)17L;
+        return EEXIST;
     }
+    private static final int ENOTDIR = (int)20L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define ENOTDIR 20
      * }
      */
     public static int ENOTDIR() {
-        return (int)20L;
+        return ENOTDIR;
     }
+    private static final int EISDIR = (int)21L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define EISDIR 21
      * }
      */
     public static int EISDIR() {
-        return (int)21L;
+        return EISDIR;
     }
+    private static final int EINVAL = (int)22L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define EINVAL 22
      * }
      */
     public static int EINVAL() {
-        return (int)22L;
+        return EINVAL;
     }
+    private static final int EROFS = (int)30L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define EROFS 30
      * }
      */
     public static int EROFS() {
-        return (int)30L;
+        return EROFS;
     }
+    private static final int ERANGE = (int)34L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define ERANGE 34
      * }
      */
     public static int ERANGE() {
-        return (int)34L;
+        return ERANGE;
     }
+    private static final int ENAMETOOLONG = (int)36L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define ENAMETOOLONG 36
      * }
      */
     public static int ENAMETOOLONG() {
-        return (int)36L;
+        return ENAMETOOLONG;
     }
+    private static final int ENOLCK = (int)37L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define ENOLCK 37
      * }
      */
     public static int ENOLCK() {
-        return (int)37L;
+        return ENOLCK;
     }
+    private static final int ENOSYS = (int)38L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define ENOSYS 38
      * }
      */
     public static int ENOSYS() {
-        return (int)38L;
+        return ENOSYS;
     }
+    private static final int ENOTEMPTY = (int)39L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define ENOTEMPTY 39
      * }
      */
     public static int ENOTEMPTY() {
-        return (int)39L;
+        return ENOTEMPTY;
     }
+    private static final int ENODATA = (int)61L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define ENODATA 61
      * }
      */
     public static int ENODATA() {
-        return (int)61L;
+        return ENODATA;
     }
+    private static final int ENOTSUP = (int)95L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define ENOTSUP 95
      * }
      */
     public static int ENOTSUP() {
-        return (int)95L;
+        return ENOTSUP;
     }
 }
 
-
diff --git a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fcntl/RuntimeHelper.java b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fcntl/RuntimeHelper.java
deleted file mode 100644
index d7be6bf9..00000000
--- a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fcntl/RuntimeHelper.java
+++ /dev/null
@@ -1,245 +0,0 @@
-package org.cryptomator.jfuse.linux.aarch64.extr.fcntl;
-// Generated by jextract
-
-import java.lang.foreign.Linker;
-import java.lang.foreign.FunctionDescriptor;
-import java.lang.foreign.GroupLayout;
-import java.lang.foreign.SymbolLookup;
-import java.lang.foreign.MemoryLayout;
-import java.lang.foreign.MemorySegment;
-import java.lang.foreign.Arena;
-import java.lang.foreign.SegmentAllocator;
-import java.lang.foreign.ValueLayout;
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.MethodHandles;
-import java.lang.invoke.MethodType;
-import java.io.File;
-import java.nio.file.Path;
-import java.nio.charset.StandardCharsets;
-import java.util.Arrays;
-import java.util.Optional;
-import java.util.stream.Stream;
-
-import java.lang.foreign.AddressLayout;
-import java.lang.foreign.MemoryLayout;
-
-import static java.lang.foreign.Linker.*;
-import static java.lang.foreign.ValueLayout.*;
-
-final class RuntimeHelper {
-
-    private static final Linker LINKER = Linker.nativeLinker();
-    private static final ClassLoader LOADER = RuntimeHelper.class.getClassLoader();
-    private static final MethodHandles.Lookup MH_LOOKUP = MethodHandles.lookup();
-    private static final SymbolLookup SYMBOL_LOOKUP;
-    private static final SegmentAllocator THROWING_ALLOCATOR = (x, y) -> { throw new AssertionError("should not reach here"); };
-    static final AddressLayout POINTER = ValueLayout.ADDRESS.withTargetLayout(MemoryLayout.sequenceLayout(JAVA_BYTE));
-
-    final static SegmentAllocator CONSTANT_ALLOCATOR =
-            (size, align) -> Arena.ofAuto().allocate(size, align);
-
-    static {
-        
-        SymbolLookup loaderLookup = SymbolLookup.loaderLookup();
-        SYMBOL_LOOKUP = name -> loaderLookup.find(name).or(() -> LINKER.defaultLookup().find(name));
-    }
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private RuntimeHelper() {}
-
-    static <T> T requireNonNull(T obj, String symbolName) {
-        if (obj == null) {
-            throw new UnsatisfiedLinkError("unresolved symbol: " + symbolName);
-        }
-        return obj;
-    }
-
-    static MemorySegment lookupGlobalVariable(String name, MemoryLayout layout) {
-        return SYMBOL_LOOKUP.find(name)
-                .map(s -> s.reinterpret(layout.byteSize()))
-                .orElse(null);
-    }
-
-    static MethodHandle downcallHandle(String name, FunctionDescriptor fdesc) {
-        return SYMBOL_LOOKUP.find(name).
-                map(addr -> LINKER.downcallHandle(addr, fdesc)).
-                orElse(null);
-    }
-
-    static MethodHandle downcallHandle(FunctionDescriptor fdesc) {
-        return LINKER.downcallHandle(fdesc);
-    }
-
-    static MethodHandle downcallHandleVariadic(String name, FunctionDescriptor fdesc) {
-        return SYMBOL_LOOKUP.find(name).
-                map(addr -> VarargsInvoker.make(addr, fdesc)).
-                orElse(null);
-    }
-
-    static MethodHandle upcallHandle(Class<?> fi, String name, FunctionDescriptor fdesc) {
-        try {
-            return MH_LOOKUP.findVirtual(fi, name, fdesc.toMethodType());
-        } catch (Throwable ex) {
-            throw new AssertionError(ex);
-        }
-    }
-
-    static <Z> MemorySegment upcallStub(MethodHandle fiHandle, Z z, FunctionDescriptor fdesc, Arena scope) {
-        try {
-            fiHandle = fiHandle.bindTo(z);
-            return LINKER.upcallStub(fiHandle, fdesc, scope);
-        } catch (Throwable ex) {
-            throw new AssertionError(ex);
-        }
-    }
-
-    static MemorySegment asArray(MemorySegment addr, MemoryLayout layout, int numElements, Arena arena) {
-         return addr.reinterpret(numElements * layout.byteSize(), arena, null);
-    }
-
-    // Internals only below this point
-
-    private static final class VarargsInvoker {
-        private static final MethodHandle INVOKE_MH;
-        private final MemorySegment symbol;
-        private final FunctionDescriptor function;
-
-        private VarargsInvoker(MemorySegment symbol, FunctionDescriptor function) {
-            this.symbol = symbol;
-            this.function = function;
-        }
-
-        static {
-            try {
-                INVOKE_MH = MethodHandles.lookup().findVirtual(VarargsInvoker.class, "invoke", MethodType.methodType(Object.class, SegmentAllocator.class, Object[].class));
-            } catch (ReflectiveOperationException e) {
-                throw new RuntimeException(e);
-            }
-        }
-
-        static MethodHandle make(MemorySegment symbol, FunctionDescriptor function) {
-            VarargsInvoker invoker = new VarargsInvoker(symbol, function);
-            MethodHandle handle = INVOKE_MH.bindTo(invoker).asCollector(Object[].class, function.argumentLayouts().size() + 1);
-            MethodType mtype = MethodType.methodType(function.returnLayout().isPresent() ? carrier(function.returnLayout().get(), true) : void.class);
-            for (MemoryLayout layout : function.argumentLayouts()) {
-                mtype = mtype.appendParameterTypes(carrier(layout, false));
-            }
-            mtype = mtype.appendParameterTypes(Object[].class);
-            boolean needsAllocator = function.returnLayout().isPresent() &&
-                                function.returnLayout().get() instanceof GroupLayout;
-            if (needsAllocator) {
-                mtype = mtype.insertParameterTypes(0, SegmentAllocator.class);
-            } else {
-                handle = MethodHandles.insertArguments(handle, 0, THROWING_ALLOCATOR);
-            }
-            return handle.asType(mtype);
-        }
-
-        static Class<?> carrier(MemoryLayout layout, boolean ret) {
-            if (layout instanceof ValueLayout valueLayout) {
-                return valueLayout.carrier();
-            } else if (layout instanceof GroupLayout) {
-                return MemorySegment.class;
-            } else {
-                throw new AssertionError("Cannot get here!");
-            }
-        }
-
-        private Object invoke(SegmentAllocator allocator, Object[] args) throws Throwable {
-            // one trailing Object[]
-            int nNamedArgs = function.argumentLayouts().size();
-            assert(args.length == nNamedArgs + 1);
-            // The last argument is the array of vararg collector
-            Object[] unnamedArgs = (Object[]) args[args.length - 1];
-
-            int argsCount = nNamedArgs + unnamedArgs.length;
-            Class<?>[] argTypes = new Class<?>[argsCount];
-            MemoryLayout[] argLayouts = new MemoryLayout[nNamedArgs + unnamedArgs.length];
-
-            int pos = 0;
-            for (pos = 0; pos < nNamedArgs; pos++) {
-                argLayouts[pos] = function.argumentLayouts().get(pos);
-            }
-
-            assert pos == nNamedArgs;
-            for (Object o: unnamedArgs) {
-                argLayouts[pos] = variadicLayout(normalize(o.getClass()));
-                pos++;
-            }
-            assert pos == argsCount;
-
-            FunctionDescriptor f = (function.returnLayout().isEmpty()) ?
-                    FunctionDescriptor.ofVoid(argLayouts) :
-                    FunctionDescriptor.of(function.returnLayout().get(), argLayouts);
-            MethodHandle mh = LINKER.downcallHandle(symbol, f);
-            boolean needsAllocator = function.returnLayout().isPresent() &&
-                                            function.returnLayout().get() instanceof GroupLayout;
-            if (needsAllocator) {
-                mh = mh.bindTo(allocator);
-            }
-            // flatten argument list so that it can be passed to an asSpreader MH
-            Object[] allArgs = new Object[nNamedArgs + unnamedArgs.length];
-            System.arraycopy(args, 0, allArgs, 0, nNamedArgs);
-            System.arraycopy(unnamedArgs, 0, allArgs, nNamedArgs, unnamedArgs.length);
-
-            return mh.asSpreader(Object[].class, argsCount).invoke(allArgs);
-        }
-
-        private static Class<?> unboxIfNeeded(Class<?> clazz) {
-            if (clazz == Boolean.class) {
-                return boolean.class;
-            } else if (clazz == Void.class) {
-                return void.class;
-            } else if (clazz == Byte.class) {
-                return byte.class;
-            } else if (clazz == Character.class) {
-                return char.class;
-            } else if (clazz == Short.class) {
-                return short.class;
-            } else if (clazz == Integer.class) {
-                return int.class;
-            } else if (clazz == Long.class) {
-                return long.class;
-            } else if (clazz == Float.class) {
-                return float.class;
-            } else if (clazz == Double.class) {
-                return double.class;
-            } else {
-                return clazz;
-            }
-        }
-
-        private Class<?> promote(Class<?> c) {
-            if (c == byte.class || c == char.class || c == short.class || c == int.class) {
-                return long.class;
-            } else if (c == float.class) {
-                return double.class;
-            } else {
-                return c;
-            }
-        }
-
-        private Class<?> normalize(Class<?> c) {
-            c = unboxIfNeeded(c);
-            if (c.isPrimitive()) {
-                return promote(c);
-            }
-            if (c == MemorySegment.class) {
-                return MemorySegment.class;
-            }
-            throw new IllegalArgumentException("Invalid type for ABI: " + c.getTypeName());
-        }
-
-        private MemoryLayout variadicLayout(Class<?> c) {
-            if (c == long.class) {
-                return JAVA_LONG;
-            } else if (c == double.class) {
-                return JAVA_DOUBLE;
-            } else if (c == MemorySegment.class) {
-                return ADDRESS;
-            } else {
-                throw new IllegalArgumentException("Unhandled variadic argument class: " + c);
-            }
-        }
-    }
-}
diff --git a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fcntl/constants$0.java b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fcntl/constants$0.java
deleted file mode 100644
index 7438ade1..00000000
--- a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fcntl/constants$0.java
+++ /dev/null
@@ -1,16 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.linux.aarch64.extr.fcntl;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$0 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$0() {}
-}
-
-
diff --git a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fcntl/fcntl_h.java b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fcntl/fcntl_h.java
index 403bbb02..898acacd 100644
--- a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fcntl/fcntl_h.java
+++ b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fcntl/fcntl_h.java
@@ -2,93 +2,152 @@
 
 package org.cryptomator.jfuse.linux.aarch64.extr.fcntl;
 
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
+import java.lang.invoke.*;
 import java.lang.foreign.*;
+import java.nio.ByteOrder;
+import java.util.*;
+import java.util.function.*;
+import java.util.stream.*;
+
 import static java.lang.foreign.ValueLayout.*;
-public class fcntl_h  {
+import static java.lang.foreign.MemoryLayout.PathElement.*;
+
+public class fcntl_h {
+
+    fcntl_h() {
+        // Should not be called directly
+    }
+
+    static final Arena LIBRARY_ARENA = Arena.ofAuto();
+    static final boolean TRACE_DOWNCALLS = Boolean.getBoolean("jextract.trace.downcalls");
+
+    static void traceDowncall(String name, Object... args) {
+         String traceArgs = Arrays.stream(args)
+                       .map(Object::toString)
+                       .collect(Collectors.joining(", "));
+         System.out.printf("%s(%s)\n", name, traceArgs);
+    }
 
-    public static final OfByte C_CHAR = JAVA_BYTE;
-    public static final OfShort C_SHORT = JAVA_SHORT;
-    public static final OfInt C_INT = JAVA_INT;
-    public static final OfLong C_LONG = JAVA_LONG;
-    public static final OfLong C_LONG_LONG = JAVA_LONG;
-    public static final OfFloat C_FLOAT = JAVA_FLOAT;
-    public static final OfDouble C_DOUBLE = JAVA_DOUBLE;
-    public static final AddressLayout C_POINTER = RuntimeHelper.POINTER;
+    static MemorySegment findOrThrow(String symbol) {
+        return SYMBOL_LOOKUP.find(symbol)
+            .orElseThrow(() -> new UnsatisfiedLinkError("unresolved symbol: " + symbol));
+    }
+
+    static MethodHandle upcallHandle(Class<?> fi, String name, FunctionDescriptor fdesc) {
+        try {
+            return MethodHandles.lookup().findVirtual(fi, name, fdesc.toMethodType());
+        } catch (ReflectiveOperationException ex) {
+            throw new AssertionError(ex);
+        }
+    }
+
+    static MemoryLayout align(MemoryLayout layout, long align) {
+        return switch (layout) {
+            case PaddingLayout p -> p;
+            case ValueLayout v -> v.withByteAlignment(align);
+            case GroupLayout g -> {
+                MemoryLayout[] alignedMembers = g.memberLayouts().stream()
+                        .map(m -> align(m, align)).toArray(MemoryLayout[]::new);
+                yield g instanceof StructLayout ?
+                        MemoryLayout.structLayout(alignedMembers) : MemoryLayout.unionLayout(alignedMembers);
+            }
+            case SequenceLayout s -> MemoryLayout.sequenceLayout(s.elementCount(), align(s.elementLayout(), align));
+        };
+    }
+
+    static final SymbolLookup SYMBOL_LOOKUP = SymbolLookup.loaderLookup()
+            .or(Linker.nativeLinker().defaultLookup());
+
+    public static final ValueLayout.OfBoolean C_BOOL = ValueLayout.JAVA_BOOLEAN;
+    public static final ValueLayout.OfByte C_CHAR = ValueLayout.JAVA_BYTE;
+    public static final ValueLayout.OfShort C_SHORT = ValueLayout.JAVA_SHORT;
+    public static final ValueLayout.OfInt C_INT = ValueLayout.JAVA_INT;
+    public static final ValueLayout.OfLong C_LONG_LONG = ValueLayout.JAVA_LONG;
+    public static final ValueLayout.OfFloat C_FLOAT = ValueLayout.JAVA_FLOAT;
+    public static final ValueLayout.OfDouble C_DOUBLE = ValueLayout.JAVA_DOUBLE;
+    public static final AddressLayout C_POINTER = ValueLayout.ADDRESS
+            .withTargetLayout(MemoryLayout.sequenceLayout(java.lang.Long.MAX_VALUE, JAVA_BYTE));
+    public static final ValueLayout.OfLong C_LONG = ValueLayout.JAVA_LONG;
+    private static final int O_RDONLY = (int)0L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define O_RDONLY 0
      * }
      */
     public static int O_RDONLY() {
-        return (int)0L;
+        return O_RDONLY;
     }
+    private static final int O_WRONLY = (int)1L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define O_WRONLY 1
      * }
      */
     public static int O_WRONLY() {
-        return (int)1L;
+        return O_WRONLY;
     }
+    private static final int O_RDWR = (int)2L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define O_RDWR 2
      * }
      */
     public static int O_RDWR() {
-        return (int)2L;
+        return O_RDWR;
     }
+    private static final int O_CREAT = (int)64L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define O_CREAT 64
      * }
      */
     public static int O_CREAT() {
-        return (int)64L;
+        return O_CREAT;
     }
+    private static final int O_EXCL = (int)128L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define O_EXCL 128
      * }
      */
     public static int O_EXCL() {
-        return (int)128L;
+        return O_EXCL;
     }
+    private static final int O_TRUNC = (int)512L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define O_TRUNC 512
      * }
      */
     public static int O_TRUNC() {
-        return (int)512L;
+        return O_TRUNC;
     }
+    private static final int O_APPEND = (int)1024L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define O_APPEND 1024
      * }
      */
     public static int O_APPEND() {
-        return (int)1024L;
+        return O_APPEND;
     }
+    private static final int O_SYNC = (int)1052672L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define O_SYNC 1052672
      * }
      */
     public static int O_SYNC() {
-        return (int)1052672L;
+        return O_SYNC;
     }
+    private static final int O_DSYNC = (int)4096L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define O_DSYNC 4096
      * }
      */
     public static int O_DSYNC() {
-        return (int)4096L;
+        return O_DSYNC;
     }
 }
 
-
diff --git a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/RuntimeHelper.java b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/RuntimeHelper.java
deleted file mode 100644
index 0422b28f..00000000
--- a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/RuntimeHelper.java
+++ /dev/null
@@ -1,245 +0,0 @@
-package org.cryptomator.jfuse.linux.aarch64.extr.fuse3;
-// Generated by jextract
-
-import java.lang.foreign.Linker;
-import java.lang.foreign.FunctionDescriptor;
-import java.lang.foreign.GroupLayout;
-import java.lang.foreign.SymbolLookup;
-import java.lang.foreign.MemoryLayout;
-import java.lang.foreign.MemorySegment;
-import java.lang.foreign.Arena;
-import java.lang.foreign.SegmentAllocator;
-import java.lang.foreign.ValueLayout;
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.MethodHandles;
-import java.lang.invoke.MethodType;
-import java.io.File;
-import java.nio.file.Path;
-import java.nio.charset.StandardCharsets;
-import java.util.Arrays;
-import java.util.Optional;
-import java.util.stream.Stream;
-
-import java.lang.foreign.AddressLayout;
-import java.lang.foreign.MemoryLayout;
-
-import static java.lang.foreign.Linker.*;
-import static java.lang.foreign.ValueLayout.*;
-
-final class RuntimeHelper {
-
-    private static final Linker LINKER = Linker.nativeLinker();
-    private static final ClassLoader LOADER = RuntimeHelper.class.getClassLoader();
-    private static final MethodHandles.Lookup MH_LOOKUP = MethodHandles.lookup();
-    private static final SymbolLookup SYMBOL_LOOKUP;
-    private static final SegmentAllocator THROWING_ALLOCATOR = (x, y) -> { throw new AssertionError("should not reach here"); };
-    static final AddressLayout POINTER = ValueLayout.ADDRESS.withTargetLayout(MemoryLayout.sequenceLayout(JAVA_BYTE));
-
-    final static SegmentAllocator CONSTANT_ALLOCATOR =
-            (size, align) -> Arena.ofAuto().allocate(size, align);
-
-    static {
-        
-        SymbolLookup loaderLookup = SymbolLookup.loaderLookup();
-        SYMBOL_LOOKUP = name -> loaderLookup.find(name).or(() -> LINKER.defaultLookup().find(name));
-    }
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private RuntimeHelper() {}
-
-    static <T> T requireNonNull(T obj, String symbolName) {
-        if (obj == null) {
-            throw new UnsatisfiedLinkError("unresolved symbol: " + symbolName);
-        }
-        return obj;
-    }
-
-    static MemorySegment lookupGlobalVariable(String name, MemoryLayout layout) {
-        return SYMBOL_LOOKUP.find(name)
-                .map(s -> s.reinterpret(layout.byteSize()))
-                .orElse(null);
-    }
-
-    static MethodHandle downcallHandle(String name, FunctionDescriptor fdesc) {
-        return SYMBOL_LOOKUP.find(name).
-                map(addr -> LINKER.downcallHandle(addr, fdesc)).
-                orElse(null);
-    }
-
-    static MethodHandle downcallHandle(FunctionDescriptor fdesc) {
-        return LINKER.downcallHandle(fdesc);
-    }
-
-    static MethodHandle downcallHandleVariadic(String name, FunctionDescriptor fdesc) {
-        return SYMBOL_LOOKUP.find(name).
-                map(addr -> VarargsInvoker.make(addr, fdesc)).
-                orElse(null);
-    }
-
-    static MethodHandle upcallHandle(Class<?> fi, String name, FunctionDescriptor fdesc) {
-        try {
-            return MH_LOOKUP.findVirtual(fi, name, fdesc.toMethodType());
-        } catch (Throwable ex) {
-            throw new AssertionError(ex);
-        }
-    }
-
-    static <Z> MemorySegment upcallStub(MethodHandle fiHandle, Z z, FunctionDescriptor fdesc, Arena scope) {
-        try {
-            fiHandle = fiHandle.bindTo(z);
-            return LINKER.upcallStub(fiHandle, fdesc, scope);
-        } catch (Throwable ex) {
-            throw new AssertionError(ex);
-        }
-    }
-
-    static MemorySegment asArray(MemorySegment addr, MemoryLayout layout, int numElements, Arena arena) {
-         return addr.reinterpret(numElements * layout.byteSize(), arena, null);
-    }
-
-    // Internals only below this point
-
-    private static final class VarargsInvoker {
-        private static final MethodHandle INVOKE_MH;
-        private final MemorySegment symbol;
-        private final FunctionDescriptor function;
-
-        private VarargsInvoker(MemorySegment symbol, FunctionDescriptor function) {
-            this.symbol = symbol;
-            this.function = function;
-        }
-
-        static {
-            try {
-                INVOKE_MH = MethodHandles.lookup().findVirtual(VarargsInvoker.class, "invoke", MethodType.methodType(Object.class, SegmentAllocator.class, Object[].class));
-            } catch (ReflectiveOperationException e) {
-                throw new RuntimeException(e);
-            }
-        }
-
-        static MethodHandle make(MemorySegment symbol, FunctionDescriptor function) {
-            VarargsInvoker invoker = new VarargsInvoker(symbol, function);
-            MethodHandle handle = INVOKE_MH.bindTo(invoker).asCollector(Object[].class, function.argumentLayouts().size() + 1);
-            MethodType mtype = MethodType.methodType(function.returnLayout().isPresent() ? carrier(function.returnLayout().get(), true) : void.class);
-            for (MemoryLayout layout : function.argumentLayouts()) {
-                mtype = mtype.appendParameterTypes(carrier(layout, false));
-            }
-            mtype = mtype.appendParameterTypes(Object[].class);
-            boolean needsAllocator = function.returnLayout().isPresent() &&
-                                function.returnLayout().get() instanceof GroupLayout;
-            if (needsAllocator) {
-                mtype = mtype.insertParameterTypes(0, SegmentAllocator.class);
-            } else {
-                handle = MethodHandles.insertArguments(handle, 0, THROWING_ALLOCATOR);
-            }
-            return handle.asType(mtype);
-        }
-
-        static Class<?> carrier(MemoryLayout layout, boolean ret) {
-            if (layout instanceof ValueLayout valueLayout) {
-                return valueLayout.carrier();
-            } else if (layout instanceof GroupLayout) {
-                return MemorySegment.class;
-            } else {
-                throw new AssertionError("Cannot get here!");
-            }
-        }
-
-        private Object invoke(SegmentAllocator allocator, Object[] args) throws Throwable {
-            // one trailing Object[]
-            int nNamedArgs = function.argumentLayouts().size();
-            assert(args.length == nNamedArgs + 1);
-            // The last argument is the array of vararg collector
-            Object[] unnamedArgs = (Object[]) args[args.length - 1];
-
-            int argsCount = nNamedArgs + unnamedArgs.length;
-            Class<?>[] argTypes = new Class<?>[argsCount];
-            MemoryLayout[] argLayouts = new MemoryLayout[nNamedArgs + unnamedArgs.length];
-
-            int pos = 0;
-            for (pos = 0; pos < nNamedArgs; pos++) {
-                argLayouts[pos] = function.argumentLayouts().get(pos);
-            }
-
-            assert pos == nNamedArgs;
-            for (Object o: unnamedArgs) {
-                argLayouts[pos] = variadicLayout(normalize(o.getClass()));
-                pos++;
-            }
-            assert pos == argsCount;
-
-            FunctionDescriptor f = (function.returnLayout().isEmpty()) ?
-                    FunctionDescriptor.ofVoid(argLayouts) :
-                    FunctionDescriptor.of(function.returnLayout().get(), argLayouts);
-            MethodHandle mh = LINKER.downcallHandle(symbol, f);
-            boolean needsAllocator = function.returnLayout().isPresent() &&
-                                            function.returnLayout().get() instanceof GroupLayout;
-            if (needsAllocator) {
-                mh = mh.bindTo(allocator);
-            }
-            // flatten argument list so that it can be passed to an asSpreader MH
-            Object[] allArgs = new Object[nNamedArgs + unnamedArgs.length];
-            System.arraycopy(args, 0, allArgs, 0, nNamedArgs);
-            System.arraycopy(unnamedArgs, 0, allArgs, nNamedArgs, unnamedArgs.length);
-
-            return mh.asSpreader(Object[].class, argsCount).invoke(allArgs);
-        }
-
-        private static Class<?> unboxIfNeeded(Class<?> clazz) {
-            if (clazz == Boolean.class) {
-                return boolean.class;
-            } else if (clazz == Void.class) {
-                return void.class;
-            } else if (clazz == Byte.class) {
-                return byte.class;
-            } else if (clazz == Character.class) {
-                return char.class;
-            } else if (clazz == Short.class) {
-                return short.class;
-            } else if (clazz == Integer.class) {
-                return int.class;
-            } else if (clazz == Long.class) {
-                return long.class;
-            } else if (clazz == Float.class) {
-                return float.class;
-            } else if (clazz == Double.class) {
-                return double.class;
-            } else {
-                return clazz;
-            }
-        }
-
-        private Class<?> promote(Class<?> c) {
-            if (c == byte.class || c == char.class || c == short.class || c == int.class) {
-                return long.class;
-            } else if (c == float.class) {
-                return double.class;
-            } else {
-                return c;
-            }
-        }
-
-        private Class<?> normalize(Class<?> c) {
-            c = unboxIfNeeded(c);
-            if (c.isPrimitive()) {
-                return promote(c);
-            }
-            if (c == MemorySegment.class) {
-                return MemorySegment.class;
-            }
-            throw new IllegalArgumentException("Invalid type for ABI: " + c.getTypeName());
-        }
-
-        private MemoryLayout variadicLayout(Class<?> c) {
-            if (c == long.class) {
-                return JAVA_LONG;
-            } else if (c == double.class) {
-                return JAVA_DOUBLE;
-            } else if (c == MemorySegment.class) {
-                return ADDRESS;
-            } else {
-                throw new IllegalArgumentException("Unhandled variadic argument class: " + c);
-            }
-        }
-    }
-}
diff --git a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$0.java b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$0.java
deleted file mode 100644
index a562930a..00000000
--- a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$0.java
+++ /dev/null
@@ -1,31 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.linux.aarch64.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$0 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$0() {}
-    static final StructLayout const$0 = MemoryLayout.structLayout(
-        JAVA_INT.withName("argc"),
-        MemoryLayout.paddingLayout(4),
-        RuntimeHelper.POINTER.withName("argv"),
-        JAVA_INT.withName("allocated"),
-        MemoryLayout.paddingLayout(4)
-    ).withName("fuse_args");
-    static final VarHandle const$1 = constants$0.const$0.varHandle(MemoryLayout.PathElement.groupElement("argc"));
-    static final VarHandle const$2 = constants$0.const$0.varHandle(MemoryLayout.PathElement.groupElement("argv"));
-    static final VarHandle const$3 = constants$0.const$0.varHandle(MemoryLayout.PathElement.groupElement("allocated"));
-    static final StructLayout const$4 = MemoryLayout.structLayout(
-        JAVA_LONG.withName("tv_sec"),
-        JAVA_LONG.withName("tv_nsec")
-    ).withName("timespec");
-    static final VarHandle const$5 = constants$0.const$4.varHandle(MemoryLayout.PathElement.groupElement("tv_sec"));
-}
-
-
diff --git a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$1.java b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$1.java
deleted file mode 100644
index a54155cc..00000000
--- a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$1.java
+++ /dev/null
@@ -1,29 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.linux.aarch64.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$1 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$1() {}
-    static final VarHandle const$0 = constants$0.const$4.varHandle(MemoryLayout.PathElement.groupElement("tv_nsec"));
-    static final StructLayout const$1 = MemoryLayout.structLayout(
-        JAVA_INT.withName("flags"),
-        MemoryLayout.paddingLayout(12),
-        JAVA_LONG.withName("fh"),
-        JAVA_LONG.withName("lock_owner"),
-        JAVA_INT.withName("poll_events"),
-        MemoryLayout.paddingLayout(4)
-    ).withName("fuse_file_info");
-    static final VarHandle const$2 = constants$1.const$1.varHandle(MemoryLayout.PathElement.groupElement("flags"));
-    static final VarHandle const$3 = constants$1.const$1.varHandle(MemoryLayout.PathElement.groupElement("fh"));
-    static final VarHandle const$4 = constants$1.const$1.varHandle(MemoryLayout.PathElement.groupElement("lock_owner"));
-    static final VarHandle const$5 = constants$1.const$1.varHandle(MemoryLayout.PathElement.groupElement("poll_events"));
-}
-
-
diff --git a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$10.java b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$10.java
deleted file mode 100644
index cdc5f05e..00000000
--- a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$10.java
+++ /dev/null
@@ -1,58 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.linux.aarch64.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$10 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$10() {}
-    static final FunctionDescriptor const$0 = FunctionDescriptor.of(JAVA_INT,
-        RuntimeHelper.POINTER,
-        RuntimeHelper.POINTER,
-        RuntimeHelper.POINTER,
-        JAVA_LONG,
-        JAVA_INT
-    );
-    static final MethodHandle const$1 = RuntimeHelper.upcallHandle(fuse_fill_dir_t.class, "apply", constants$10.const$0);
-    static final MethodHandle const$2 = RuntimeHelper.downcallHandle(
-        constants$10.const$0
-    );
-    static final StructLayout const$3 = MemoryLayout.structLayout(
-        JAVA_INT.withName("set_gid"),
-        JAVA_INT.withName("gid"),
-        JAVA_INT.withName("set_uid"),
-        JAVA_INT.withName("uid"),
-        JAVA_INT.withName("set_mode"),
-        JAVA_INT.withName("umask"),
-        JAVA_DOUBLE.withName("entry_timeout"),
-        JAVA_DOUBLE.withName("negative_timeout"),
-        JAVA_DOUBLE.withName("attr_timeout"),
-        JAVA_INT.withName("intr"),
-        JAVA_INT.withName("intr_signal"),
-        JAVA_INT.withName("remember"),
-        JAVA_INT.withName("hard_remove"),
-        JAVA_INT.withName("use_ino"),
-        JAVA_INT.withName("readdir_ino"),
-        JAVA_INT.withName("direct_io"),
-        JAVA_INT.withName("kernel_cache"),
-        JAVA_INT.withName("auto_cache"),
-        JAVA_INT.withName("no_rofd_flush"),
-        JAVA_INT.withName("ac_attr_timeout_set"),
-        MemoryLayout.paddingLayout(4),
-        JAVA_DOUBLE.withName("ac_attr_timeout"),
-        JAVA_INT.withName("nullpath_ok"),
-        JAVA_INT.withName("show_help"),
-        RuntimeHelper.POINTER.withName("modules"),
-        JAVA_INT.withName("debug"),
-        MemoryLayout.paddingLayout(4)
-    ).withName("fuse_config");
-    static final VarHandle const$4 = constants$10.const$3.varHandle(MemoryLayout.PathElement.groupElement("set_gid"));
-    static final VarHandle const$5 = constants$10.const$3.varHandle(MemoryLayout.PathElement.groupElement("gid"));
-}
-
-
diff --git a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$11.java b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$11.java
deleted file mode 100644
index e1aff91d..00000000
--- a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$11.java
+++ /dev/null
@@ -1,22 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.linux.aarch64.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$11 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$11() {}
-    static final VarHandle const$0 = constants$10.const$3.varHandle(MemoryLayout.PathElement.groupElement("set_uid"));
-    static final VarHandle const$1 = constants$10.const$3.varHandle(MemoryLayout.PathElement.groupElement("uid"));
-    static final VarHandle const$2 = constants$10.const$3.varHandle(MemoryLayout.PathElement.groupElement("set_mode"));
-    static final VarHandle const$3 = constants$10.const$3.varHandle(MemoryLayout.PathElement.groupElement("umask"));
-    static final VarHandle const$4 = constants$10.const$3.varHandle(MemoryLayout.PathElement.groupElement("entry_timeout"));
-    static final VarHandle const$5 = constants$10.const$3.varHandle(MemoryLayout.PathElement.groupElement("negative_timeout"));
-}
-
-
diff --git a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$12.java b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$12.java
deleted file mode 100644
index c02651b0..00000000
--- a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$12.java
+++ /dev/null
@@ -1,22 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.linux.aarch64.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$12 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$12() {}
-    static final VarHandle const$0 = constants$10.const$3.varHandle(MemoryLayout.PathElement.groupElement("attr_timeout"));
-    static final VarHandle const$1 = constants$10.const$3.varHandle(MemoryLayout.PathElement.groupElement("intr"));
-    static final VarHandle const$2 = constants$10.const$3.varHandle(MemoryLayout.PathElement.groupElement("intr_signal"));
-    static final VarHandle const$3 = constants$10.const$3.varHandle(MemoryLayout.PathElement.groupElement("remember"));
-    static final VarHandle const$4 = constants$10.const$3.varHandle(MemoryLayout.PathElement.groupElement("hard_remove"));
-    static final VarHandle const$5 = constants$10.const$3.varHandle(MemoryLayout.PathElement.groupElement("use_ino"));
-}
-
-
diff --git a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$13.java b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$13.java
deleted file mode 100644
index 657796ed..00000000
--- a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$13.java
+++ /dev/null
@@ -1,22 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.linux.aarch64.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$13 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$13() {}
-    static final VarHandle const$0 = constants$10.const$3.varHandle(MemoryLayout.PathElement.groupElement("readdir_ino"));
-    static final VarHandle const$1 = constants$10.const$3.varHandle(MemoryLayout.PathElement.groupElement("direct_io"));
-    static final VarHandle const$2 = constants$10.const$3.varHandle(MemoryLayout.PathElement.groupElement("kernel_cache"));
-    static final VarHandle const$3 = constants$10.const$3.varHandle(MemoryLayout.PathElement.groupElement("auto_cache"));
-    static final VarHandle const$4 = constants$10.const$3.varHandle(MemoryLayout.PathElement.groupElement("no_rofd_flush"));
-    static final VarHandle const$5 = constants$10.const$3.varHandle(MemoryLayout.PathElement.groupElement("ac_attr_timeout_set"));
-}
-
-
diff --git a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$14.java b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$14.java
deleted file mode 100644
index 8ed08413..00000000
--- a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$14.java
+++ /dev/null
@@ -1,65 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.linux.aarch64.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$14 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$14() {}
-    static final VarHandle const$0 = constants$10.const$3.varHandle(MemoryLayout.PathElement.groupElement("ac_attr_timeout"));
-    static final VarHandle const$1 = constants$10.const$3.varHandle(MemoryLayout.PathElement.groupElement("nullpath_ok"));
-    static final VarHandle const$2 = constants$10.const$3.varHandle(MemoryLayout.PathElement.groupElement("show_help"));
-    static final VarHandle const$3 = constants$10.const$3.varHandle(MemoryLayout.PathElement.groupElement("modules"));
-    static final VarHandle const$4 = constants$10.const$3.varHandle(MemoryLayout.PathElement.groupElement("debug"));
-    static final StructLayout const$5 = MemoryLayout.structLayout(
-        RuntimeHelper.POINTER.withName("getattr"),
-        RuntimeHelper.POINTER.withName("readlink"),
-        RuntimeHelper.POINTER.withName("mknod"),
-        RuntimeHelper.POINTER.withName("mkdir"),
-        RuntimeHelper.POINTER.withName("unlink"),
-        RuntimeHelper.POINTER.withName("rmdir"),
-        RuntimeHelper.POINTER.withName("symlink"),
-        RuntimeHelper.POINTER.withName("rename"),
-        RuntimeHelper.POINTER.withName("link"),
-        RuntimeHelper.POINTER.withName("chmod"),
-        RuntimeHelper.POINTER.withName("chown"),
-        RuntimeHelper.POINTER.withName("truncate"),
-        RuntimeHelper.POINTER.withName("open"),
-        RuntimeHelper.POINTER.withName("read"),
-        RuntimeHelper.POINTER.withName("write"),
-        RuntimeHelper.POINTER.withName("statfs"),
-        RuntimeHelper.POINTER.withName("flush"),
-        RuntimeHelper.POINTER.withName("release"),
-        RuntimeHelper.POINTER.withName("fsync"),
-        RuntimeHelper.POINTER.withName("setxattr"),
-        RuntimeHelper.POINTER.withName("getxattr"),
-        RuntimeHelper.POINTER.withName("listxattr"),
-        RuntimeHelper.POINTER.withName("removexattr"),
-        RuntimeHelper.POINTER.withName("opendir"),
-        RuntimeHelper.POINTER.withName("readdir"),
-        RuntimeHelper.POINTER.withName("releasedir"),
-        RuntimeHelper.POINTER.withName("fsyncdir"),
-        RuntimeHelper.POINTER.withName("init"),
-        RuntimeHelper.POINTER.withName("destroy"),
-        RuntimeHelper.POINTER.withName("access"),
-        RuntimeHelper.POINTER.withName("create"),
-        RuntimeHelper.POINTER.withName("lock"),
-        RuntimeHelper.POINTER.withName("utimens"),
-        RuntimeHelper.POINTER.withName("bmap"),
-        RuntimeHelper.POINTER.withName("ioctl"),
-        RuntimeHelper.POINTER.withName("poll"),
-        RuntimeHelper.POINTER.withName("write_buf"),
-        RuntimeHelper.POINTER.withName("read_buf"),
-        RuntimeHelper.POINTER.withName("flock"),
-        RuntimeHelper.POINTER.withName("fallocate"),
-        RuntimeHelper.POINTER.withName("copy_file_range"),
-        RuntimeHelper.POINTER.withName("lseek")
-    ).withName("fuse_operations");
-}
-
-
diff --git a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$15.java b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$15.java
deleted file mode 100644
index bdca941e..00000000
--- a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$15.java
+++ /dev/null
@@ -1,32 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.linux.aarch64.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$15 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$15() {}
-    static final FunctionDescriptor const$0 = FunctionDescriptor.of(JAVA_INT,
-        RuntimeHelper.POINTER,
-        RuntimeHelper.POINTER,
-        RuntimeHelper.POINTER
-    );
-    static final MethodHandle const$1 = RuntimeHelper.upcallHandle(fuse_operations.getattr.class, "apply", constants$15.const$0);
-    static final MethodHandle const$2 = RuntimeHelper.downcallHandle(
-        constants$15.const$0
-    );
-    static final VarHandle const$3 = constants$14.const$5.varHandle(MemoryLayout.PathElement.groupElement("getattr"));
-    static final FunctionDescriptor const$4 = FunctionDescriptor.of(JAVA_INT,
-        RuntimeHelper.POINTER,
-        RuntimeHelper.POINTER,
-        JAVA_LONG
-    );
-    static final MethodHandle const$5 = RuntimeHelper.upcallHandle(fuse_operations.readlink.class, "apply", constants$15.const$4);
-}
-
-
diff --git a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$16.java b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$16.java
deleted file mode 100644
index 25ce7679..00000000
--- a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$16.java
+++ /dev/null
@@ -1,30 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.linux.aarch64.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$16 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$16() {}
-    static final MethodHandle const$0 = RuntimeHelper.downcallHandle(
-        constants$15.const$4
-    );
-    static final VarHandle const$1 = constants$14.const$5.varHandle(MemoryLayout.PathElement.groupElement("readlink"));
-    static final FunctionDescriptor const$2 = FunctionDescriptor.of(JAVA_INT,
-        RuntimeHelper.POINTER,
-        JAVA_INT,
-        JAVA_LONG
-    );
-    static final MethodHandle const$3 = RuntimeHelper.upcallHandle(fuse_operations.mknod.class, "apply", constants$16.const$2);
-    static final MethodHandle const$4 = RuntimeHelper.downcallHandle(
-        constants$16.const$2
-    );
-    static final VarHandle const$5 = constants$14.const$5.varHandle(MemoryLayout.PathElement.groupElement("mknod"));
-}
-
-
diff --git a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$17.java b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$17.java
deleted file mode 100644
index ac2c0ca7..00000000
--- a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$17.java
+++ /dev/null
@@ -1,29 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.linux.aarch64.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$17 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$17() {}
-    static final FunctionDescriptor const$0 = FunctionDescriptor.of(JAVA_INT,
-        RuntimeHelper.POINTER,
-        JAVA_INT
-    );
-    static final MethodHandle const$1 = RuntimeHelper.upcallHandle(fuse_operations.mkdir.class, "apply", constants$17.const$0);
-    static final MethodHandle const$2 = RuntimeHelper.downcallHandle(
-        constants$17.const$0
-    );
-    static final VarHandle const$3 = constants$14.const$5.varHandle(MemoryLayout.PathElement.groupElement("mkdir"));
-    static final FunctionDescriptor const$4 = FunctionDescriptor.of(JAVA_INT,
-        RuntimeHelper.POINTER
-    );
-    static final MethodHandle const$5 = RuntimeHelper.upcallHandle(fuse_operations.unlink.class, "apply", constants$17.const$4);
-}
-
-
diff --git a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$18.java b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$18.java
deleted file mode 100644
index 49fa93f1..00000000
--- a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$18.java
+++ /dev/null
@@ -1,27 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.linux.aarch64.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$18 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$18() {}
-    static final MethodHandle const$0 = RuntimeHelper.downcallHandle(
-        constants$17.const$4
-    );
-    static final VarHandle const$1 = constants$14.const$5.varHandle(MemoryLayout.PathElement.groupElement("unlink"));
-    static final MethodHandle const$2 = RuntimeHelper.upcallHandle(fuse_operations.rmdir.class, "apply", constants$17.const$4);
-    static final VarHandle const$3 = constants$14.const$5.varHandle(MemoryLayout.PathElement.groupElement("rmdir"));
-    static final FunctionDescriptor const$4 = FunctionDescriptor.of(JAVA_INT,
-        RuntimeHelper.POINTER,
-        RuntimeHelper.POINTER
-    );
-    static final MethodHandle const$5 = RuntimeHelper.upcallHandle(fuse_operations.symlink.class, "apply", constants$18.const$4);
-}
-
-
diff --git a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$19.java b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$19.java
deleted file mode 100644
index 2394bd0b..00000000
--- a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$19.java
+++ /dev/null
@@ -1,30 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.linux.aarch64.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$19 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$19() {}
-    static final MethodHandle const$0 = RuntimeHelper.downcallHandle(
-        constants$18.const$4
-    );
-    static final VarHandle const$1 = constants$14.const$5.varHandle(MemoryLayout.PathElement.groupElement("symlink"));
-    static final FunctionDescriptor const$2 = FunctionDescriptor.of(JAVA_INT,
-        RuntimeHelper.POINTER,
-        RuntimeHelper.POINTER,
-        JAVA_INT
-    );
-    static final MethodHandle const$3 = RuntimeHelper.upcallHandle(fuse_operations.rename.class, "apply", constants$19.const$2);
-    static final MethodHandle const$4 = RuntimeHelper.downcallHandle(
-        constants$19.const$2
-    );
-    static final VarHandle const$5 = constants$14.const$5.varHandle(MemoryLayout.PathElement.groupElement("rename"));
-}
-
-
diff --git a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$2.java b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$2.java
deleted file mode 100644
index 085bb1af..00000000
--- a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$2.java
+++ /dev/null
@@ -1,37 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.linux.aarch64.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$2 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$2() {}
-    static final StructLayout const$0 = MemoryLayout.structLayout(
-        JAVA_INT.withName("clone_fd"),
-        JAVA_INT.withName("max_idle_threads")
-    ).withName("fuse_loop_config_v1");
-    static final VarHandle const$1 = constants$2.const$0.varHandle(MemoryLayout.PathElement.groupElement("clone_fd"));
-    static final VarHandle const$2 = constants$2.const$0.varHandle(MemoryLayout.PathElement.groupElement("max_idle_threads"));
-    static final StructLayout const$3 = MemoryLayout.structLayout(
-        JAVA_INT.withName("proto_major"),
-        JAVA_INT.withName("proto_minor"),
-        JAVA_INT.withName("max_write"),
-        JAVA_INT.withName("max_read"),
-        JAVA_INT.withName("max_readahead"),
-        JAVA_INT.withName("capable"),
-        JAVA_INT.withName("want"),
-        JAVA_INT.withName("max_background"),
-        JAVA_INT.withName("congestion_threshold"),
-        JAVA_INT.withName("time_gran"),
-        MemoryLayout.sequenceLayout(22, JAVA_INT).withName("reserved")
-    ).withName("fuse_conn_info");
-    static final VarHandle const$4 = constants$2.const$3.varHandle(MemoryLayout.PathElement.groupElement("proto_major"));
-    static final VarHandle const$5 = constants$2.const$3.varHandle(MemoryLayout.PathElement.groupElement("proto_minor"));
-}
-
-
diff --git a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$20.java b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$20.java
deleted file mode 100644
index 7c0cbe6c..00000000
--- a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$20.java
+++ /dev/null
@@ -1,28 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.linux.aarch64.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$20 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$20() {}
-    static final MethodHandle const$0 = RuntimeHelper.upcallHandle(fuse_operations.link.class, "apply", constants$18.const$4);
-    static final VarHandle const$1 = constants$14.const$5.varHandle(MemoryLayout.PathElement.groupElement("link"));
-    static final FunctionDescriptor const$2 = FunctionDescriptor.of(JAVA_INT,
-        RuntimeHelper.POINTER,
-        JAVA_INT,
-        RuntimeHelper.POINTER
-    );
-    static final MethodHandle const$3 = RuntimeHelper.upcallHandle(fuse_operations.chmod.class, "apply", constants$20.const$2);
-    static final MethodHandle const$4 = RuntimeHelper.downcallHandle(
-        constants$20.const$2
-    );
-    static final VarHandle const$5 = constants$14.const$5.varHandle(MemoryLayout.PathElement.groupElement("chmod"));
-}
-
-
diff --git a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$21.java b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$21.java
deleted file mode 100644
index e41c328c..00000000
--- a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$21.java
+++ /dev/null
@@ -1,33 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.linux.aarch64.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$21 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$21() {}
-    static final FunctionDescriptor const$0 = FunctionDescriptor.of(JAVA_INT,
-        RuntimeHelper.POINTER,
-        JAVA_INT,
-        JAVA_INT,
-        RuntimeHelper.POINTER
-    );
-    static final MethodHandle const$1 = RuntimeHelper.upcallHandle(fuse_operations.chown.class, "apply", constants$21.const$0);
-    static final MethodHandle const$2 = RuntimeHelper.downcallHandle(
-        constants$21.const$0
-    );
-    static final VarHandle const$3 = constants$14.const$5.varHandle(MemoryLayout.PathElement.groupElement("chown"));
-    static final FunctionDescriptor const$4 = FunctionDescriptor.of(JAVA_INT,
-        RuntimeHelper.POINTER,
-        JAVA_LONG,
-        RuntimeHelper.POINTER
-    );
-    static final MethodHandle const$5 = RuntimeHelper.upcallHandle(fuse_operations.truncate.class, "apply", constants$21.const$4);
-}
-
-
diff --git a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$22.java b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$22.java
deleted file mode 100644
index e575bc0a..00000000
--- a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$22.java
+++ /dev/null
@@ -1,30 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.linux.aarch64.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$22 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$22() {}
-    static final MethodHandle const$0 = RuntimeHelper.downcallHandle(
-        constants$21.const$4
-    );
-    static final VarHandle const$1 = constants$14.const$5.varHandle(MemoryLayout.PathElement.groupElement("truncate"));
-    static final MethodHandle const$2 = RuntimeHelper.upcallHandle(fuse_operations.open.class, "apply", constants$18.const$4);
-    static final VarHandle const$3 = constants$14.const$5.varHandle(MemoryLayout.PathElement.groupElement("open"));
-    static final FunctionDescriptor const$4 = FunctionDescriptor.of(JAVA_INT,
-        RuntimeHelper.POINTER,
-        RuntimeHelper.POINTER,
-        JAVA_LONG,
-        JAVA_LONG,
-        RuntimeHelper.POINTER
-    );
-    static final MethodHandle const$5 = RuntimeHelper.upcallHandle(fuse_operations.read.class, "apply", constants$22.const$4);
-}
-
-
diff --git a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$23.java b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$23.java
deleted file mode 100644
index be4be51a..00000000
--- a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$23.java
+++ /dev/null
@@ -1,24 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.linux.aarch64.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$23 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$23() {}
-    static final MethodHandle const$0 = RuntimeHelper.downcallHandle(
-        constants$22.const$4
-    );
-    static final VarHandle const$1 = constants$14.const$5.varHandle(MemoryLayout.PathElement.groupElement("read"));
-    static final MethodHandle const$2 = RuntimeHelper.upcallHandle(fuse_operations.write.class, "apply", constants$22.const$4);
-    static final VarHandle const$3 = constants$14.const$5.varHandle(MemoryLayout.PathElement.groupElement("write"));
-    static final MethodHandle const$4 = RuntimeHelper.upcallHandle(fuse_operations.statfs.class, "apply", constants$18.const$4);
-    static final VarHandle const$5 = constants$14.const$5.varHandle(MemoryLayout.PathElement.groupElement("statfs"));
-}
-
-
diff --git a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$24.java b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$24.java
deleted file mode 100644
index daf306e2..00000000
--- a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$24.java
+++ /dev/null
@@ -1,22 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.linux.aarch64.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$24 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$24() {}
-    static final MethodHandle const$0 = RuntimeHelper.upcallHandle(fuse_operations.flush.class, "apply", constants$18.const$4);
-    static final VarHandle const$1 = constants$14.const$5.varHandle(MemoryLayout.PathElement.groupElement("flush"));
-    static final MethodHandle const$2 = RuntimeHelper.upcallHandle(fuse_operations.release.class, "apply", constants$18.const$4);
-    static final VarHandle const$3 = constants$14.const$5.varHandle(MemoryLayout.PathElement.groupElement("release"));
-    static final MethodHandle const$4 = RuntimeHelper.upcallHandle(fuse_operations.fsync.class, "apply", constants$20.const$2);
-    static final VarHandle const$5 = constants$14.const$5.varHandle(MemoryLayout.PathElement.groupElement("fsync"));
-}
-
-
diff --git a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$25.java b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$25.java
deleted file mode 100644
index 84cd32de..00000000
--- a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$25.java
+++ /dev/null
@@ -1,29 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.linux.aarch64.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$25 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$25() {}
-    static final MethodHandle const$0 = RuntimeHelper.upcallHandle(fuse_operations.setxattr.class, "apply", constants$10.const$0);
-    static final VarHandle const$1 = constants$14.const$5.varHandle(MemoryLayout.PathElement.groupElement("setxattr"));
-    static final FunctionDescriptor const$2 = FunctionDescriptor.of(JAVA_INT,
-        RuntimeHelper.POINTER,
-        RuntimeHelper.POINTER,
-        RuntimeHelper.POINTER,
-        JAVA_LONG
-    );
-    static final MethodHandle const$3 = RuntimeHelper.upcallHandle(fuse_operations.getxattr.class, "apply", constants$25.const$2);
-    static final MethodHandle const$4 = RuntimeHelper.downcallHandle(
-        constants$25.const$2
-    );
-    static final VarHandle const$5 = constants$14.const$5.varHandle(MemoryLayout.PathElement.groupElement("getxattr"));
-}
-
-
diff --git a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$26.java b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$26.java
deleted file mode 100644
index 459dcc55..00000000
--- a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$26.java
+++ /dev/null
@@ -1,22 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.linux.aarch64.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$26 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$26() {}
-    static final MethodHandle const$0 = RuntimeHelper.upcallHandle(fuse_operations.listxattr.class, "apply", constants$15.const$4);
-    static final VarHandle const$1 = constants$14.const$5.varHandle(MemoryLayout.PathElement.groupElement("listxattr"));
-    static final MethodHandle const$2 = RuntimeHelper.upcallHandle(fuse_operations.removexattr.class, "apply", constants$18.const$4);
-    static final VarHandle const$3 = constants$14.const$5.varHandle(MemoryLayout.PathElement.groupElement("removexattr"));
-    static final MethodHandle const$4 = RuntimeHelper.upcallHandle(fuse_operations.opendir.class, "apply", constants$18.const$4);
-    static final VarHandle const$5 = constants$14.const$5.varHandle(MemoryLayout.PathElement.groupElement("opendir"));
-}
-
-
diff --git a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$27.java b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$27.java
deleted file mode 100644
index b12c5d99..00000000
--- a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$27.java
+++ /dev/null
@@ -1,31 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.linux.aarch64.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$27 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$27() {}
-    static final FunctionDescriptor const$0 = FunctionDescriptor.of(JAVA_INT,
-        RuntimeHelper.POINTER,
-        RuntimeHelper.POINTER,
-        RuntimeHelper.POINTER,
-        JAVA_LONG,
-        RuntimeHelper.POINTER,
-        JAVA_INT
-    );
-    static final MethodHandle const$1 = RuntimeHelper.upcallHandle(fuse_operations.readdir.class, "apply", constants$27.const$0);
-    static final MethodHandle const$2 = RuntimeHelper.downcallHandle(
-        constants$27.const$0
-    );
-    static final VarHandle const$3 = constants$14.const$5.varHandle(MemoryLayout.PathElement.groupElement("readdir"));
-    static final MethodHandle const$4 = RuntimeHelper.upcallHandle(fuse_operations.releasedir.class, "apply", constants$18.const$4);
-    static final VarHandle const$5 = constants$14.const$5.varHandle(MemoryLayout.PathElement.groupElement("releasedir"));
-}
-
-
diff --git a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$28.java b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$28.java
deleted file mode 100644
index e0d4545a..00000000
--- a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$28.java
+++ /dev/null
@@ -1,27 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.linux.aarch64.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$28 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$28() {}
-    static final MethodHandle const$0 = RuntimeHelper.upcallHandle(fuse_operations.fsyncdir.class, "apply", constants$20.const$2);
-    static final VarHandle const$1 = constants$14.const$5.varHandle(MemoryLayout.PathElement.groupElement("fsyncdir"));
-    static final FunctionDescriptor const$2 = FunctionDescriptor.of(RuntimeHelper.POINTER,
-        RuntimeHelper.POINTER,
-        RuntimeHelper.POINTER
-    );
-    static final MethodHandle const$3 = RuntimeHelper.upcallHandle(fuse_operations.init.class, "apply", constants$28.const$2);
-    static final MethodHandle const$4 = RuntimeHelper.downcallHandle(
-        constants$28.const$2
-    );
-    static final VarHandle const$5 = constants$14.const$5.varHandle(MemoryLayout.PathElement.groupElement("init"));
-}
-
-
diff --git a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$29.java b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$29.java
deleted file mode 100644
index 0fcf4628..00000000
--- a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$29.java
+++ /dev/null
@@ -1,24 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.linux.aarch64.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$29 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$29() {}
-    static final MethodHandle const$0 = RuntimeHelper.upcallHandle(fuse_operations.destroy.class, "apply", constants$5.const$0);
-    static final MethodHandle const$1 = RuntimeHelper.downcallHandle(
-        constants$5.const$0
-    );
-    static final VarHandle const$2 = constants$14.const$5.varHandle(MemoryLayout.PathElement.groupElement("destroy"));
-    static final MethodHandle const$3 = RuntimeHelper.upcallHandle(fuse_operations.access.class, "apply", constants$17.const$0);
-    static final VarHandle const$4 = constants$14.const$5.varHandle(MemoryLayout.PathElement.groupElement("access"));
-    static final MethodHandle const$5 = RuntimeHelper.upcallHandle(fuse_operations.create.class, "apply", constants$20.const$2);
-}
-
-
diff --git a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$3.java b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$3.java
deleted file mode 100644
index 0d9c12cf..00000000
--- a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$3.java
+++ /dev/null
@@ -1,22 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.linux.aarch64.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$3 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$3() {}
-    static final VarHandle const$0 = constants$2.const$3.varHandle(MemoryLayout.PathElement.groupElement("max_write"));
-    static final VarHandle const$1 = constants$2.const$3.varHandle(MemoryLayout.PathElement.groupElement("max_read"));
-    static final VarHandle const$2 = constants$2.const$3.varHandle(MemoryLayout.PathElement.groupElement("max_readahead"));
-    static final VarHandle const$3 = constants$2.const$3.varHandle(MemoryLayout.PathElement.groupElement("capable"));
-    static final VarHandle const$4 = constants$2.const$3.varHandle(MemoryLayout.PathElement.groupElement("want"));
-    static final VarHandle const$5 = constants$2.const$3.varHandle(MemoryLayout.PathElement.groupElement("max_background"));
-}
-
-
diff --git a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$30.java b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$30.java
deleted file mode 100644
index a40b0ce3..00000000
--- a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$30.java
+++ /dev/null
@@ -1,29 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.linux.aarch64.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$30 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$30() {}
-    static final VarHandle const$0 = constants$14.const$5.varHandle(MemoryLayout.PathElement.groupElement("create"));
-    static final FunctionDescriptor const$1 = FunctionDescriptor.of(JAVA_INT,
-        RuntimeHelper.POINTER,
-        RuntimeHelper.POINTER,
-        JAVA_INT,
-        RuntimeHelper.POINTER
-    );
-    static final MethodHandle const$2 = RuntimeHelper.upcallHandle(fuse_operations.lock.class, "apply", constants$30.const$1);
-    static final MethodHandle const$3 = RuntimeHelper.downcallHandle(
-        constants$30.const$1
-    );
-    static final VarHandle const$4 = constants$14.const$5.varHandle(MemoryLayout.PathElement.groupElement("lock"));
-    static final MethodHandle const$5 = RuntimeHelper.upcallHandle(fuse_operations.utimens.class, "apply", constants$15.const$0);
-}
-
-
diff --git a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$31.java b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$31.java
deleted file mode 100644
index 88b03af5..00000000
--- a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$31.java
+++ /dev/null
@@ -1,31 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.linux.aarch64.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$31 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$31() {}
-    static final VarHandle const$0 = constants$14.const$5.varHandle(MemoryLayout.PathElement.groupElement("utimens"));
-    static final MethodHandle const$1 = RuntimeHelper.upcallHandle(fuse_operations.bmap.class, "apply", constants$21.const$4);
-    static final VarHandle const$2 = constants$14.const$5.varHandle(MemoryLayout.PathElement.groupElement("bmap"));
-    static final FunctionDescriptor const$3 = FunctionDescriptor.of(JAVA_INT,
-        RuntimeHelper.POINTER,
-        JAVA_INT,
-        RuntimeHelper.POINTER,
-        RuntimeHelper.POINTER,
-        JAVA_INT,
-        RuntimeHelper.POINTER
-    );
-    static final MethodHandle const$4 = RuntimeHelper.upcallHandle(fuse_operations.ioctl.class, "apply", constants$31.const$3);
-    static final MethodHandle const$5 = RuntimeHelper.downcallHandle(
-        constants$31.const$3
-    );
-}
-
-
diff --git a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$32.java b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$32.java
deleted file mode 100644
index fba5108f..00000000
--- a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$32.java
+++ /dev/null
@@ -1,34 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.linux.aarch64.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$32 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$32() {}
-    static final VarHandle const$0 = constants$14.const$5.varHandle(MemoryLayout.PathElement.groupElement("ioctl"));
-    static final FunctionDescriptor const$1 = FunctionDescriptor.of(JAVA_INT,
-        RuntimeHelper.POINTER,
-        RuntimeHelper.POINTER,
-        RuntimeHelper.POINTER,
-        RuntimeHelper.POINTER
-    );
-    static final MethodHandle const$2 = RuntimeHelper.upcallHandle(fuse_operations.poll.class, "apply", constants$32.const$1);
-    static final MethodHandle const$3 = RuntimeHelper.downcallHandle(
-        constants$32.const$1
-    );
-    static final VarHandle const$4 = constants$14.const$5.varHandle(MemoryLayout.PathElement.groupElement("poll"));
-    static final FunctionDescriptor const$5 = FunctionDescriptor.of(JAVA_INT,
-        RuntimeHelper.POINTER,
-        RuntimeHelper.POINTER,
-        JAVA_LONG,
-        RuntimeHelper.POINTER
-    );
-}
-
-
diff --git a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$33.java b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$33.java
deleted file mode 100644
index 321bbe6e..00000000
--- a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$33.java
+++ /dev/null
@@ -1,24 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.linux.aarch64.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$33 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$33() {}
-    static final MethodHandle const$0 = RuntimeHelper.upcallHandle(fuse_operations.write_buf.class, "apply", constants$32.const$5);
-    static final MethodHandle const$1 = RuntimeHelper.downcallHandle(
-        constants$32.const$5
-    );
-    static final VarHandle const$2 = constants$14.const$5.varHandle(MemoryLayout.PathElement.groupElement("write_buf"));
-    static final MethodHandle const$3 = RuntimeHelper.upcallHandle(fuse_operations.read_buf.class, "apply", constants$22.const$4);
-    static final VarHandle const$4 = constants$14.const$5.varHandle(MemoryLayout.PathElement.groupElement("read_buf"));
-    static final MethodHandle const$5 = RuntimeHelper.upcallHandle(fuse_operations.flock.class, "apply", constants$19.const$2);
-}
-
-
diff --git a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$34.java b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$34.java
deleted file mode 100644
index 06528fa4..00000000
--- a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$34.java
+++ /dev/null
@@ -1,39 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.linux.aarch64.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$34 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$34() {}
-    static final VarHandle const$0 = constants$14.const$5.varHandle(MemoryLayout.PathElement.groupElement("flock"));
-    static final FunctionDescriptor const$1 = FunctionDescriptor.of(JAVA_INT,
-        RuntimeHelper.POINTER,
-        JAVA_INT,
-        JAVA_LONG,
-        JAVA_LONG,
-        RuntimeHelper.POINTER
-    );
-    static final MethodHandle const$2 = RuntimeHelper.upcallHandle(fuse_operations.fallocate.class, "apply", constants$34.const$1);
-    static final MethodHandle const$3 = RuntimeHelper.downcallHandle(
-        constants$34.const$1
-    );
-    static final VarHandle const$4 = constants$14.const$5.varHandle(MemoryLayout.PathElement.groupElement("fallocate"));
-    static final FunctionDescriptor const$5 = FunctionDescriptor.of(JAVA_LONG,
-        RuntimeHelper.POINTER,
-        RuntimeHelper.POINTER,
-        JAVA_LONG,
-        RuntimeHelper.POINTER,
-        RuntimeHelper.POINTER,
-        JAVA_LONG,
-        JAVA_LONG,
-        JAVA_INT
-    );
-}
-
-
diff --git a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$35.java b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$35.java
deleted file mode 100644
index cdab26e9..00000000
--- a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$35.java
+++ /dev/null
@@ -1,31 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.linux.aarch64.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$35 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$35() {}
-    static final MethodHandle const$0 = RuntimeHelper.upcallHandle(fuse_operations.copy_file_range.class, "apply", constants$34.const$5);
-    static final MethodHandle const$1 = RuntimeHelper.downcallHandle(
-        constants$34.const$5
-    );
-    static final VarHandle const$2 = constants$14.const$5.varHandle(MemoryLayout.PathElement.groupElement("copy_file_range"));
-    static final FunctionDescriptor const$3 = FunctionDescriptor.of(JAVA_LONG,
-        RuntimeHelper.POINTER,
-        JAVA_LONG,
-        JAVA_INT,
-        RuntimeHelper.POINTER
-    );
-    static final MethodHandle const$4 = RuntimeHelper.upcallHandle(fuse_operations.lseek.class, "apply", constants$35.const$3);
-    static final MethodHandle const$5 = RuntimeHelper.downcallHandle(
-        constants$35.const$3
-    );
-}
-
-
diff --git a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$36.java b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$36.java
deleted file mode 100644
index 99fe7878..00000000
--- a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$36.java
+++ /dev/null
@@ -1,39 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.linux.aarch64.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$36 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$36() {}
-    static final VarHandle const$0 = constants$14.const$5.varHandle(MemoryLayout.PathElement.groupElement("lseek"));
-    static final MethodHandle const$1 = RuntimeHelper.downcallHandle(
-        "fuse_lib_help",
-        constants$5.const$0
-    );
-    static final FunctionDescriptor const$2 = FunctionDescriptor.of(RuntimeHelper.POINTER,
-        RuntimeHelper.POINTER,
-        RuntimeHelper.POINTER,
-        JAVA_LONG,
-        RuntimeHelper.POINTER
-    );
-    static final MethodHandle const$3 = RuntimeHelper.downcallHandle(
-        "fuse_new",
-        constants$36.const$2
-    );
-    static final MethodHandle const$4 = RuntimeHelper.downcallHandle(
-        "fuse_mount",
-        constants$18.const$4
-    );
-    static final MethodHandle const$5 = RuntimeHelper.downcallHandle(
-        "fuse_unmount",
-        constants$5.const$0
-    );
-}
-
-
diff --git a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$37.java b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$37.java
deleted file mode 100644
index e1d45d61..00000000
--- a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$37.java
+++ /dev/null
@@ -1,39 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.linux.aarch64.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$37 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$37() {}
-    static final MethodHandle const$0 = RuntimeHelper.downcallHandle(
-        "fuse_destroy",
-        constants$5.const$0
-    );
-    static final MethodHandle const$1 = RuntimeHelper.downcallHandle(
-        "fuse_loop",
-        constants$17.const$4
-    );
-    static final MethodHandle const$2 = RuntimeHelper.downcallHandle(
-        "fuse_exit",
-        constants$5.const$0
-    );
-    static final MethodHandle const$3 = RuntimeHelper.downcallHandle(
-        "fuse_loop_mt",
-        constants$18.const$4
-    );
-    static final FunctionDescriptor const$4 = FunctionDescriptor.of(RuntimeHelper.POINTER,
-        RuntimeHelper.POINTER
-    );
-    static final MethodHandle const$5 = RuntimeHelper.downcallHandle(
-        "fuse_get_session",
-        constants$37.const$4
-    );
-}
-
-
diff --git a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$4.java b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$4.java
deleted file mode 100644
index 24a608b4..00000000
--- a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$4.java
+++ /dev/null
@@ -1,28 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.linux.aarch64.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$4 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$4() {}
-    static final VarHandle const$0 = constants$2.const$3.varHandle(MemoryLayout.PathElement.groupElement("congestion_threshold"));
-    static final VarHandle const$1 = constants$2.const$3.varHandle(MemoryLayout.PathElement.groupElement("time_gran"));
-    static final FunctionDescriptor const$2 = FunctionDescriptor.of(JAVA_INT);
-    static final MethodHandle const$3 = RuntimeHelper.downcallHandle(
-        "fuse_version",
-        constants$4.const$2
-    );
-    static final FunctionDescriptor const$4 = FunctionDescriptor.of(RuntimeHelper.POINTER);
-    static final MethodHandle const$5 = RuntimeHelper.downcallHandle(
-        "fuse_loop_cfg_create",
-        constants$4.const$4
-    );
-}
-
-
diff --git a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$5.java b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$5.java
deleted file mode 100644
index 67198842..00000000
--- a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$5.java
+++ /dev/null
@@ -1,62 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.linux.aarch64.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$5 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$5() {}
-    static final FunctionDescriptor const$0 = FunctionDescriptor.ofVoid(
-        RuntimeHelper.POINTER
-    );
-    static final MethodHandle const$1 = RuntimeHelper.downcallHandle(
-        "fuse_loop_cfg_destroy",
-        constants$5.const$0
-    );
-    static final FunctionDescriptor const$2 = FunctionDescriptor.ofVoid(
-        RuntimeHelper.POINTER,
-        JAVA_INT
-    );
-    static final MethodHandle const$3 = RuntimeHelper.downcallHandle(
-        "fuse_loop_cfg_set_max_threads",
-        constants$5.const$2
-    );
-    static final MethodHandle const$4 = RuntimeHelper.downcallHandle(
-        "fuse_loop_cfg_set_clone_fd",
-        constants$5.const$2
-    );
-    static final StructLayout const$5 = MemoryLayout.structLayout(
-        JAVA_LONG.withName("st_dev"),
-        JAVA_LONG.withName("st_ino"),
-        JAVA_INT.withName("st_mode"),
-        JAVA_INT.withName("st_nlink"),
-        JAVA_INT.withName("st_uid"),
-        JAVA_INT.withName("st_gid"),
-        JAVA_LONG.withName("st_rdev"),
-        JAVA_LONG.withName("__pad1"),
-        JAVA_LONG.withName("st_size"),
-        JAVA_INT.withName("st_blksize"),
-        JAVA_INT.withName("__pad2"),
-        JAVA_LONG.withName("st_blocks"),
-        MemoryLayout.structLayout(
-            JAVA_LONG.withName("tv_sec"),
-            JAVA_LONG.withName("tv_nsec")
-        ).withName("st_atim"),
-        MemoryLayout.structLayout(
-            JAVA_LONG.withName("tv_sec"),
-            JAVA_LONG.withName("tv_nsec")
-        ).withName("st_mtim"),
-        MemoryLayout.structLayout(
-            JAVA_LONG.withName("tv_sec"),
-            JAVA_LONG.withName("tv_nsec")
-        ).withName("st_ctim"),
-        MemoryLayout.sequenceLayout(2, JAVA_INT).withName("__glibc_reserved")
-    ).withName("stat");
-}
-
-
diff --git a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$6.java b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$6.java
deleted file mode 100644
index f5764a52..00000000
--- a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$6.java
+++ /dev/null
@@ -1,22 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.linux.aarch64.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$6 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$6() {}
-    static final VarHandle const$0 = constants$5.const$5.varHandle(MemoryLayout.PathElement.groupElement("st_dev"));
-    static final VarHandle const$1 = constants$5.const$5.varHandle(MemoryLayout.PathElement.groupElement("st_ino"));
-    static final VarHandle const$2 = constants$5.const$5.varHandle(MemoryLayout.PathElement.groupElement("st_mode"));
-    static final VarHandle const$3 = constants$5.const$5.varHandle(MemoryLayout.PathElement.groupElement("st_nlink"));
-    static final VarHandle const$4 = constants$5.const$5.varHandle(MemoryLayout.PathElement.groupElement("st_uid"));
-    static final VarHandle const$5 = constants$5.const$5.varHandle(MemoryLayout.PathElement.groupElement("st_gid"));
-}
-
-
diff --git a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$7.java b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$7.java
deleted file mode 100644
index 03bcc49e..00000000
--- a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$7.java
+++ /dev/null
@@ -1,22 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.linux.aarch64.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$7 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$7() {}
-    static final VarHandle const$0 = constants$5.const$5.varHandle(MemoryLayout.PathElement.groupElement("st_rdev"));
-    static final VarHandle const$1 = constants$5.const$5.varHandle(MemoryLayout.PathElement.groupElement("__pad1"));
-    static final VarHandle const$2 = constants$5.const$5.varHandle(MemoryLayout.PathElement.groupElement("st_size"));
-    static final VarHandle const$3 = constants$5.const$5.varHandle(MemoryLayout.PathElement.groupElement("st_blksize"));
-    static final VarHandle const$4 = constants$5.const$5.varHandle(MemoryLayout.PathElement.groupElement("__pad2"));
-    static final VarHandle const$5 = constants$5.const$5.varHandle(MemoryLayout.PathElement.groupElement("st_blocks"));
-}
-
-
diff --git a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$8.java b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$8.java
deleted file mode 100644
index f88e1dd7..00000000
--- a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$8.java
+++ /dev/null
@@ -1,35 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.linux.aarch64.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$8 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$8() {}
-    static final StructLayout const$0 = MemoryLayout.structLayout(
-        JAVA_LONG.withName("f_bsize"),
-        JAVA_LONG.withName("f_frsize"),
-        JAVA_LONG.withName("f_blocks"),
-        JAVA_LONG.withName("f_bfree"),
-        JAVA_LONG.withName("f_bavail"),
-        JAVA_LONG.withName("f_files"),
-        JAVA_LONG.withName("f_ffree"),
-        JAVA_LONG.withName("f_favail"),
-        JAVA_LONG.withName("f_fsid"),
-        JAVA_LONG.withName("f_flag"),
-        JAVA_LONG.withName("f_namemax"),
-        MemoryLayout.sequenceLayout(6, JAVA_INT).withName("__f_spare")
-    ).withName("statvfs");
-    static final VarHandle const$1 = constants$8.const$0.varHandle(MemoryLayout.PathElement.groupElement("f_bsize"));
-    static final VarHandle const$2 = constants$8.const$0.varHandle(MemoryLayout.PathElement.groupElement("f_frsize"));
-    static final VarHandle const$3 = constants$8.const$0.varHandle(MemoryLayout.PathElement.groupElement("f_blocks"));
-    static final VarHandle const$4 = constants$8.const$0.varHandle(MemoryLayout.PathElement.groupElement("f_bfree"));
-    static final VarHandle const$5 = constants$8.const$0.varHandle(MemoryLayout.PathElement.groupElement("f_bavail"));
-}
-
-
diff --git a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$9.java b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$9.java
deleted file mode 100644
index 05e7d44f..00000000
--- a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/constants$9.java
+++ /dev/null
@@ -1,22 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.linux.aarch64.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$9 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$9() {}
-    static final VarHandle const$0 = constants$8.const$0.varHandle(MemoryLayout.PathElement.groupElement("f_files"));
-    static final VarHandle const$1 = constants$8.const$0.varHandle(MemoryLayout.PathElement.groupElement("f_ffree"));
-    static final VarHandle const$2 = constants$8.const$0.varHandle(MemoryLayout.PathElement.groupElement("f_favail"));
-    static final VarHandle const$3 = constants$8.const$0.varHandle(MemoryLayout.PathElement.groupElement("f_fsid"));
-    static final VarHandle const$4 = constants$8.const$0.varHandle(MemoryLayout.PathElement.groupElement("f_flag"));
-    static final VarHandle const$5 = constants$8.const$0.varHandle(MemoryLayout.PathElement.groupElement("f_namemax"));
-}
-
-
diff --git a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/fuse_args.java b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/fuse_args.java
index 29a132ac..643e6192 100644
--- a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/fuse_args.java
+++ b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/fuse_args.java
@@ -2,112 +2,220 @@
 
 package org.cryptomator.jfuse.linux.aarch64.extr.fuse3;
 
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
+import java.lang.invoke.*;
 import java.lang.foreign.*;
+import java.nio.ByteOrder;
+import java.util.*;
+import java.util.function.*;
+import java.util.stream.*;
+
 import static java.lang.foreign.ValueLayout.*;
+import static java.lang.foreign.MemoryLayout.PathElement.*;
+
 /**
- * {@snippet :
+ * {@snippet lang=c :
  * struct fuse_args {
  *     int argc;
- *     char** argv;
+ *     char **argv;
  *     int allocated;
- * };
+ * }
  * }
  */
 public class fuse_args {
 
-    public static MemoryLayout $LAYOUT() {
-        return constants$0.const$0;
+    fuse_args() {
+        // Should not be called directly
+    }
+
+    private static final GroupLayout $LAYOUT = MemoryLayout.structLayout(
+        fuse_h.C_INT.withName("argc"),
+        MemoryLayout.paddingLayout(4),
+        fuse_h.C_POINTER.withName("argv"),
+        fuse_h.C_INT.withName("allocated"),
+        MemoryLayout.paddingLayout(4)
+    ).withName("fuse_args");
+
+    /**
+     * The layout of this struct
+     */
+    public static final GroupLayout layout() {
+        return $LAYOUT;
     }
-    public static VarHandle argc$VH() {
-        return constants$0.const$1;
+
+    private static final OfInt argc$LAYOUT = (OfInt)$LAYOUT.select(groupElement("argc"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int argc
+     * }
+     */
+    public static final OfInt argc$layout() {
+        return argc$LAYOUT;
     }
+
+    private static final long argc$OFFSET = 0;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int argc
+     * }
+     */
+    public static final long argc$offset() {
+        return argc$OFFSET;
+    }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int argc;
+     * {@snippet lang=c :
+     * int argc
      * }
      */
-    public static int argc$get(MemorySegment seg) {
-        return (int)constants$0.const$1.get(seg);
+    public static int argc(MemorySegment struct) {
+        return struct.get(argc$LAYOUT, argc$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int argc;
+     * {@snippet lang=c :
+     * int argc
      * }
      */
-    public static void argc$set(MemorySegment seg, int x) {
-        constants$0.const$1.set(seg, x);
+    public static void argc(MemorySegment struct, int fieldValue) {
+        struct.set(argc$LAYOUT, argc$OFFSET, fieldValue);
     }
-    public static int argc$get(MemorySegment seg, long index) {
-        return (int)constants$0.const$1.get(seg.asSlice(index*sizeof()));
-    }
-    public static void argc$set(MemorySegment seg, long index, int x) {
-        constants$0.const$1.set(seg.asSlice(index*sizeof()), x);
+
+    private static final AddressLayout argv$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("argv"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * char **argv
+     * }
+     */
+    public static final AddressLayout argv$layout() {
+        return argv$LAYOUT;
     }
-    public static VarHandle argv$VH() {
-        return constants$0.const$2;
+
+    private static final long argv$OFFSET = 8;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * char **argv
+     * }
+     */
+    public static final long argv$offset() {
+        return argv$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * char** argv;
+     * {@snippet lang=c :
+     * char **argv
      * }
      */
-    public static MemorySegment argv$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$0.const$2.get(seg);
+    public static MemorySegment argv(MemorySegment struct) {
+        return struct.get(argv$LAYOUT, argv$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * char** argv;
+     * {@snippet lang=c :
+     * char **argv
      * }
      */
-    public static void argv$set(MemorySegment seg, MemorySegment x) {
-        constants$0.const$2.set(seg, x);
-    }
-    public static MemorySegment argv$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$0.const$2.get(seg.asSlice(index*sizeof()));
+    public static void argv(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(argv$LAYOUT, argv$OFFSET, fieldValue);
     }
-    public static void argv$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$0.const$2.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt allocated$LAYOUT = (OfInt)$LAYOUT.select(groupElement("allocated"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int allocated
+     * }
+     */
+    public static final OfInt allocated$layout() {
+        return allocated$LAYOUT;
     }
-    public static VarHandle allocated$VH() {
-        return constants$0.const$3;
+
+    private static final long allocated$OFFSET = 16;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int allocated
+     * }
+     */
+    public static final long allocated$offset() {
+        return allocated$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int allocated;
+     * {@snippet lang=c :
+     * int allocated
      * }
      */
-    public static int allocated$get(MemorySegment seg) {
-        return (int)constants$0.const$3.get(seg);
+    public static int allocated(MemorySegment struct) {
+        return struct.get(allocated$LAYOUT, allocated$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int allocated;
+     * {@snippet lang=c :
+     * int allocated
      * }
      */
-    public static void allocated$set(MemorySegment seg, int x) {
-        constants$0.const$3.set(seg, x);
+    public static void allocated(MemorySegment struct, int fieldValue) {
+        struct.set(allocated$LAYOUT, allocated$OFFSET, fieldValue);
     }
-    public static int allocated$get(MemorySegment seg, long index) {
-        return (int)constants$0.const$3.get(seg.asSlice(index*sizeof()));
+
+    /**
+     * Obtains a slice of {@code arrayParam} which selects the array element at {@code index}.
+     * The returned segment has address {@code arrayParam.address() + index * layout().byteSize()}
+     */
+    public static MemorySegment asSlice(MemorySegment array, long index) {
+        return array.asSlice(layout().byteSize() * index);
     }
-    public static void allocated$set(MemorySegment seg, long index, int x) {
-        constants$0.const$3.set(seg.asSlice(index*sizeof()), x);
+
+    /**
+     * The size (in bytes) of this struct
+     */
+    public static long sizeof() { return layout().byteSize(); }
+
+    /**
+     * Allocate a segment of size {@code layout().byteSize()} using {@code allocator}
+     */
+    public static MemorySegment allocate(SegmentAllocator allocator) {
+        return allocator.allocate(layout());
     }
-    public static long sizeof() { return $LAYOUT().byteSize(); }
-    public static MemorySegment allocate(SegmentAllocator allocator) { return allocator.allocate($LAYOUT()); }
-    public static MemorySegment allocateArray(long len, SegmentAllocator allocator) {
-        return allocator.allocate(MemoryLayout.sequenceLayout(len, $LAYOUT()));
+
+    /**
+     * Allocate an array of size {@code elementCount} using {@code allocator}.
+     * The returned segment has size {@code elementCount * layout().byteSize()}.
+     */
+    public static MemorySegment allocateArray(long elementCount, SegmentAllocator allocator) {
+        return allocator.allocate(MemoryLayout.sequenceLayout(elementCount, layout()));
     }
-    public static MemorySegment ofAddress(MemorySegment addr, Arena scope) { return RuntimeHelper.asArray(addr, $LAYOUT(), 1, scope); }
-}
 
+    /**
+     * Reinterprets {@code addr} using target {@code arena} and {@code cleanupAction) (if any).
+     * The returned segment has size {@code layout().byteSize()}
+     */
+    public static MemorySegment reinterpret(MemorySegment addr, Arena arena, Consumer<MemorySegment> cleanup) {
+        return reinterpret(addr, 1, arena, cleanup);
+    }
+
+    /**
+     * Reinterprets {@code addr} using target {@code arena} and {@code cleanupAction) (if any).
+     * The returned segment has size {@code elementCount * layout().byteSize()}
+     */
+    public static MemorySegment reinterpret(MemorySegment addr, long elementCount, Arena arena, Consumer<MemorySegment> cleanup) {
+        return addr.reinterpret(layout().byteSize() * elementCount, arena, cleanup);
+    }
+}
 
diff --git a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/fuse_config.java b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/fuse_config.java
index 6d6a4bda..d2089e1f 100644
--- a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/fuse_config.java
+++ b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/fuse_config.java
@@ -2,13 +2,18 @@
 
 package org.cryptomator.jfuse.linux.aarch64.extr.fuse3;
 
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
+import java.lang.invoke.*;
 import java.lang.foreign.*;
+import java.nio.ByteOrder;
+import java.util.*;
+import java.util.function.*;
+import java.util.stream.*;
+
 import static java.lang.foreign.ValueLayout.*;
+import static java.lang.foreign.MemoryLayout.PathElement.*;
+
 /**
- * {@snippet :
+ * {@snippet lang=c :
  * struct fuse_config {
  *     int set_gid;
  *     unsigned int gid;
@@ -33,697 +38,1196 @@
  *     double ac_attr_timeout;
  *     int nullpath_ok;
  *     int show_help;
- *     char* modules;
+ *     char *modules;
  *     int debug;
- * };
+ * }
  * }
  */
 public class fuse_config {
 
-    public static MemoryLayout $LAYOUT() {
-        return constants$10.const$3;
+    fuse_config() {
+        // Should not be called directly
     }
-    public static VarHandle set_gid$VH() {
-        return constants$10.const$4;
+
+    private static final GroupLayout $LAYOUT = MemoryLayout.structLayout(
+        fuse_h.C_INT.withName("set_gid"),
+        fuse_h.C_INT.withName("gid"),
+        fuse_h.C_INT.withName("set_uid"),
+        fuse_h.C_INT.withName("uid"),
+        fuse_h.C_INT.withName("set_mode"),
+        fuse_h.C_INT.withName("umask"),
+        fuse_h.C_DOUBLE.withName("entry_timeout"),
+        fuse_h.C_DOUBLE.withName("negative_timeout"),
+        fuse_h.C_DOUBLE.withName("attr_timeout"),
+        fuse_h.C_INT.withName("intr"),
+        fuse_h.C_INT.withName("intr_signal"),
+        fuse_h.C_INT.withName("remember"),
+        fuse_h.C_INT.withName("hard_remove"),
+        fuse_h.C_INT.withName("use_ino"),
+        fuse_h.C_INT.withName("readdir_ino"),
+        fuse_h.C_INT.withName("direct_io"),
+        fuse_h.C_INT.withName("kernel_cache"),
+        fuse_h.C_INT.withName("auto_cache"),
+        fuse_h.C_INT.withName("no_rofd_flush"),
+        fuse_h.C_INT.withName("ac_attr_timeout_set"),
+        MemoryLayout.paddingLayout(4),
+        fuse_h.C_DOUBLE.withName("ac_attr_timeout"),
+        fuse_h.C_INT.withName("nullpath_ok"),
+        fuse_h.C_INT.withName("show_help"),
+        fuse_h.C_POINTER.withName("modules"),
+        fuse_h.C_INT.withName("debug"),
+        MemoryLayout.paddingLayout(4)
+    ).withName("fuse_config");
+
+    /**
+     * The layout of this struct
+     */
+    public static final GroupLayout layout() {
+        return $LAYOUT;
     }
+
+    private static final OfInt set_gid$LAYOUT = (OfInt)$LAYOUT.select(groupElement("set_gid"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int set_gid
+     * }
+     */
+    public static final OfInt set_gid$layout() {
+        return set_gid$LAYOUT;
+    }
+
+    private static final long set_gid$OFFSET = 0;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int set_gid
+     * }
+     */
+    public static final long set_gid$offset() {
+        return set_gid$OFFSET;
+    }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int set_gid;
+     * {@snippet lang=c :
+     * int set_gid
      * }
      */
-    public static int set_gid$get(MemorySegment seg) {
-        return (int)constants$10.const$4.get(seg);
+    public static int set_gid(MemorySegment struct) {
+        return struct.get(set_gid$LAYOUT, set_gid$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int set_gid;
+     * {@snippet lang=c :
+     * int set_gid
      * }
      */
-    public static void set_gid$set(MemorySegment seg, int x) {
-        constants$10.const$4.set(seg, x);
+    public static void set_gid(MemorySegment struct, int fieldValue) {
+        struct.set(set_gid$LAYOUT, set_gid$OFFSET, fieldValue);
     }
-    public static int set_gid$get(MemorySegment seg, long index) {
-        return (int)constants$10.const$4.get(seg.asSlice(index*sizeof()));
-    }
-    public static void set_gid$set(MemorySegment seg, long index, int x) {
-        constants$10.const$4.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt gid$LAYOUT = (OfInt)$LAYOUT.select(groupElement("gid"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * unsigned int gid
+     * }
+     */
+    public static final OfInt gid$layout() {
+        return gid$LAYOUT;
     }
-    public static VarHandle gid$VH() {
-        return constants$10.const$5;
+
+    private static final long gid$OFFSET = 4;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * unsigned int gid
+     * }
+     */
+    public static final long gid$offset() {
+        return gid$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned int gid;
+     * {@snippet lang=c :
+     * unsigned int gid
      * }
      */
-    public static int gid$get(MemorySegment seg) {
-        return (int)constants$10.const$5.get(seg);
+    public static int gid(MemorySegment struct) {
+        return struct.get(gid$LAYOUT, gid$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned int gid;
+     * {@snippet lang=c :
+     * unsigned int gid
      * }
      */
-    public static void gid$set(MemorySegment seg, int x) {
-        constants$10.const$5.set(seg, x);
-    }
-    public static int gid$get(MemorySegment seg, long index) {
-        return (int)constants$10.const$5.get(seg.asSlice(index*sizeof()));
+    public static void gid(MemorySegment struct, int fieldValue) {
+        struct.set(gid$LAYOUT, gid$OFFSET, fieldValue);
     }
-    public static void gid$set(MemorySegment seg, long index, int x) {
-        constants$10.const$5.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt set_uid$LAYOUT = (OfInt)$LAYOUT.select(groupElement("set_uid"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int set_uid
+     * }
+     */
+    public static final OfInt set_uid$layout() {
+        return set_uid$LAYOUT;
     }
-    public static VarHandle set_uid$VH() {
-        return constants$11.const$0;
+
+    private static final long set_uid$OFFSET = 8;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int set_uid
+     * }
+     */
+    public static final long set_uid$offset() {
+        return set_uid$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int set_uid;
+     * {@snippet lang=c :
+     * int set_uid
      * }
      */
-    public static int set_uid$get(MemorySegment seg) {
-        return (int)constants$11.const$0.get(seg);
+    public static int set_uid(MemorySegment struct) {
+        return struct.get(set_uid$LAYOUT, set_uid$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int set_uid;
+     * {@snippet lang=c :
+     * int set_uid
      * }
      */
-    public static void set_uid$set(MemorySegment seg, int x) {
-        constants$11.const$0.set(seg, x);
-    }
-    public static int set_uid$get(MemorySegment seg, long index) {
-        return (int)constants$11.const$0.get(seg.asSlice(index*sizeof()));
+    public static void set_uid(MemorySegment struct, int fieldValue) {
+        struct.set(set_uid$LAYOUT, set_uid$OFFSET, fieldValue);
     }
-    public static void set_uid$set(MemorySegment seg, long index, int x) {
-        constants$11.const$0.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt uid$LAYOUT = (OfInt)$LAYOUT.select(groupElement("uid"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * unsigned int uid
+     * }
+     */
+    public static final OfInt uid$layout() {
+        return uid$LAYOUT;
     }
-    public static VarHandle uid$VH() {
-        return constants$11.const$1;
+
+    private static final long uid$OFFSET = 12;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * unsigned int uid
+     * }
+     */
+    public static final long uid$offset() {
+        return uid$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned int uid;
+     * {@snippet lang=c :
+     * unsigned int uid
      * }
      */
-    public static int uid$get(MemorySegment seg) {
-        return (int)constants$11.const$1.get(seg);
+    public static int uid(MemorySegment struct) {
+        return struct.get(uid$LAYOUT, uid$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned int uid;
+     * {@snippet lang=c :
+     * unsigned int uid
      * }
      */
-    public static void uid$set(MemorySegment seg, int x) {
-        constants$11.const$1.set(seg, x);
+    public static void uid(MemorySegment struct, int fieldValue) {
+        struct.set(uid$LAYOUT, uid$OFFSET, fieldValue);
     }
-    public static int uid$get(MemorySegment seg, long index) {
-        return (int)constants$11.const$1.get(seg.asSlice(index*sizeof()));
-    }
-    public static void uid$set(MemorySegment seg, long index, int x) {
-        constants$11.const$1.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt set_mode$LAYOUT = (OfInt)$LAYOUT.select(groupElement("set_mode"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int set_mode
+     * }
+     */
+    public static final OfInt set_mode$layout() {
+        return set_mode$LAYOUT;
     }
-    public static VarHandle set_mode$VH() {
-        return constants$11.const$2;
+
+    private static final long set_mode$OFFSET = 16;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int set_mode
+     * }
+     */
+    public static final long set_mode$offset() {
+        return set_mode$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int set_mode;
+     * {@snippet lang=c :
+     * int set_mode
      * }
      */
-    public static int set_mode$get(MemorySegment seg) {
-        return (int)constants$11.const$2.get(seg);
+    public static int set_mode(MemorySegment struct) {
+        return struct.get(set_mode$LAYOUT, set_mode$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int set_mode;
+     * {@snippet lang=c :
+     * int set_mode
      * }
      */
-    public static void set_mode$set(MemorySegment seg, int x) {
-        constants$11.const$2.set(seg, x);
-    }
-    public static int set_mode$get(MemorySegment seg, long index) {
-        return (int)constants$11.const$2.get(seg.asSlice(index*sizeof()));
+    public static void set_mode(MemorySegment struct, int fieldValue) {
+        struct.set(set_mode$LAYOUT, set_mode$OFFSET, fieldValue);
     }
-    public static void set_mode$set(MemorySegment seg, long index, int x) {
-        constants$11.const$2.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt umask$LAYOUT = (OfInt)$LAYOUT.select(groupElement("umask"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * unsigned int umask
+     * }
+     */
+    public static final OfInt umask$layout() {
+        return umask$LAYOUT;
     }
-    public static VarHandle umask$VH() {
-        return constants$11.const$3;
+
+    private static final long umask$OFFSET = 20;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * unsigned int umask
+     * }
+     */
+    public static final long umask$offset() {
+        return umask$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned int umask;
+     * {@snippet lang=c :
+     * unsigned int umask
      * }
      */
-    public static int umask$get(MemorySegment seg) {
-        return (int)constants$11.const$3.get(seg);
+    public static int umask(MemorySegment struct) {
+        return struct.get(umask$LAYOUT, umask$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned int umask;
+     * {@snippet lang=c :
+     * unsigned int umask
      * }
      */
-    public static void umask$set(MemorySegment seg, int x) {
-        constants$11.const$3.set(seg, x);
-    }
-    public static int umask$get(MemorySegment seg, long index) {
-        return (int)constants$11.const$3.get(seg.asSlice(index*sizeof()));
+    public static void umask(MemorySegment struct, int fieldValue) {
+        struct.set(umask$LAYOUT, umask$OFFSET, fieldValue);
     }
-    public static void umask$set(MemorySegment seg, long index, int x) {
-        constants$11.const$3.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfDouble entry_timeout$LAYOUT = (OfDouble)$LAYOUT.select(groupElement("entry_timeout"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * double entry_timeout
+     * }
+     */
+    public static final OfDouble entry_timeout$layout() {
+        return entry_timeout$LAYOUT;
     }
-    public static VarHandle entry_timeout$VH() {
-        return constants$11.const$4;
+
+    private static final long entry_timeout$OFFSET = 24;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * double entry_timeout
+     * }
+     */
+    public static final long entry_timeout$offset() {
+        return entry_timeout$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * double entry_timeout;
+     * {@snippet lang=c :
+     * double entry_timeout
      * }
      */
-    public static double entry_timeout$get(MemorySegment seg) {
-        return (double)constants$11.const$4.get(seg);
+    public static double entry_timeout(MemorySegment struct) {
+        return struct.get(entry_timeout$LAYOUT, entry_timeout$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * double entry_timeout;
+     * {@snippet lang=c :
+     * double entry_timeout
      * }
      */
-    public static void entry_timeout$set(MemorySegment seg, double x) {
-        constants$11.const$4.set(seg, x);
+    public static void entry_timeout(MemorySegment struct, double fieldValue) {
+        struct.set(entry_timeout$LAYOUT, entry_timeout$OFFSET, fieldValue);
     }
-    public static double entry_timeout$get(MemorySegment seg, long index) {
-        return (double)constants$11.const$4.get(seg.asSlice(index*sizeof()));
-    }
-    public static void entry_timeout$set(MemorySegment seg, long index, double x) {
-        constants$11.const$4.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfDouble negative_timeout$LAYOUT = (OfDouble)$LAYOUT.select(groupElement("negative_timeout"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * double negative_timeout
+     * }
+     */
+    public static final OfDouble negative_timeout$layout() {
+        return negative_timeout$LAYOUT;
     }
-    public static VarHandle negative_timeout$VH() {
-        return constants$11.const$5;
+
+    private static final long negative_timeout$OFFSET = 32;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * double negative_timeout
+     * }
+     */
+    public static final long negative_timeout$offset() {
+        return negative_timeout$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * double negative_timeout;
+     * {@snippet lang=c :
+     * double negative_timeout
      * }
      */
-    public static double negative_timeout$get(MemorySegment seg) {
-        return (double)constants$11.const$5.get(seg);
+    public static double negative_timeout(MemorySegment struct) {
+        return struct.get(negative_timeout$LAYOUT, negative_timeout$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * double negative_timeout;
+     * {@snippet lang=c :
+     * double negative_timeout
      * }
      */
-    public static void negative_timeout$set(MemorySegment seg, double x) {
-        constants$11.const$5.set(seg, x);
-    }
-    public static double negative_timeout$get(MemorySegment seg, long index) {
-        return (double)constants$11.const$5.get(seg.asSlice(index*sizeof()));
+    public static void negative_timeout(MemorySegment struct, double fieldValue) {
+        struct.set(negative_timeout$LAYOUT, negative_timeout$OFFSET, fieldValue);
     }
-    public static void negative_timeout$set(MemorySegment seg, long index, double x) {
-        constants$11.const$5.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfDouble attr_timeout$LAYOUT = (OfDouble)$LAYOUT.select(groupElement("attr_timeout"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * double attr_timeout
+     * }
+     */
+    public static final OfDouble attr_timeout$layout() {
+        return attr_timeout$LAYOUT;
     }
-    public static VarHandle attr_timeout$VH() {
-        return constants$12.const$0;
+
+    private static final long attr_timeout$OFFSET = 40;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * double attr_timeout
+     * }
+     */
+    public static final long attr_timeout$offset() {
+        return attr_timeout$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * double attr_timeout;
+     * {@snippet lang=c :
+     * double attr_timeout
      * }
      */
-    public static double attr_timeout$get(MemorySegment seg) {
-        return (double)constants$12.const$0.get(seg);
+    public static double attr_timeout(MemorySegment struct) {
+        return struct.get(attr_timeout$LAYOUT, attr_timeout$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * double attr_timeout;
+     * {@snippet lang=c :
+     * double attr_timeout
      * }
      */
-    public static void attr_timeout$set(MemorySegment seg, double x) {
-        constants$12.const$0.set(seg, x);
-    }
-    public static double attr_timeout$get(MemorySegment seg, long index) {
-        return (double)constants$12.const$0.get(seg.asSlice(index*sizeof()));
+    public static void attr_timeout(MemorySegment struct, double fieldValue) {
+        struct.set(attr_timeout$LAYOUT, attr_timeout$OFFSET, fieldValue);
     }
-    public static void attr_timeout$set(MemorySegment seg, long index, double x) {
-        constants$12.const$0.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt intr$LAYOUT = (OfInt)$LAYOUT.select(groupElement("intr"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int intr
+     * }
+     */
+    public static final OfInt intr$layout() {
+        return intr$LAYOUT;
     }
-    public static VarHandle intr$VH() {
-        return constants$12.const$1;
+
+    private static final long intr$OFFSET = 48;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int intr
+     * }
+     */
+    public static final long intr$offset() {
+        return intr$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int intr;
+     * {@snippet lang=c :
+     * int intr
      * }
      */
-    public static int intr$get(MemorySegment seg) {
-        return (int)constants$12.const$1.get(seg);
+    public static int intr(MemorySegment struct) {
+        return struct.get(intr$LAYOUT, intr$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int intr;
+     * {@snippet lang=c :
+     * int intr
      * }
      */
-    public static void intr$set(MemorySegment seg, int x) {
-        constants$12.const$1.set(seg, x);
+    public static void intr(MemorySegment struct, int fieldValue) {
+        struct.set(intr$LAYOUT, intr$OFFSET, fieldValue);
     }
-    public static int intr$get(MemorySegment seg, long index) {
-        return (int)constants$12.const$1.get(seg.asSlice(index*sizeof()));
-    }
-    public static void intr$set(MemorySegment seg, long index, int x) {
-        constants$12.const$1.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt intr_signal$LAYOUT = (OfInt)$LAYOUT.select(groupElement("intr_signal"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int intr_signal
+     * }
+     */
+    public static final OfInt intr_signal$layout() {
+        return intr_signal$LAYOUT;
     }
-    public static VarHandle intr_signal$VH() {
-        return constants$12.const$2;
+
+    private static final long intr_signal$OFFSET = 52;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int intr_signal
+     * }
+     */
+    public static final long intr_signal$offset() {
+        return intr_signal$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int intr_signal;
+     * {@snippet lang=c :
+     * int intr_signal
      * }
      */
-    public static int intr_signal$get(MemorySegment seg) {
-        return (int)constants$12.const$2.get(seg);
+    public static int intr_signal(MemorySegment struct) {
+        return struct.get(intr_signal$LAYOUT, intr_signal$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int intr_signal;
+     * {@snippet lang=c :
+     * int intr_signal
      * }
      */
-    public static void intr_signal$set(MemorySegment seg, int x) {
-        constants$12.const$2.set(seg, x);
-    }
-    public static int intr_signal$get(MemorySegment seg, long index) {
-        return (int)constants$12.const$2.get(seg.asSlice(index*sizeof()));
+    public static void intr_signal(MemorySegment struct, int fieldValue) {
+        struct.set(intr_signal$LAYOUT, intr_signal$OFFSET, fieldValue);
     }
-    public static void intr_signal$set(MemorySegment seg, long index, int x) {
-        constants$12.const$2.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt remember$LAYOUT = (OfInt)$LAYOUT.select(groupElement("remember"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int remember
+     * }
+     */
+    public static final OfInt remember$layout() {
+        return remember$LAYOUT;
     }
-    public static VarHandle remember$VH() {
-        return constants$12.const$3;
+
+    private static final long remember$OFFSET = 56;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int remember
+     * }
+     */
+    public static final long remember$offset() {
+        return remember$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int remember;
+     * {@snippet lang=c :
+     * int remember
      * }
      */
-    public static int remember$get(MemorySegment seg) {
-        return (int)constants$12.const$3.get(seg);
+    public static int remember(MemorySegment struct) {
+        return struct.get(remember$LAYOUT, remember$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int remember;
+     * {@snippet lang=c :
+     * int remember
      * }
      */
-    public static void remember$set(MemorySegment seg, int x) {
-        constants$12.const$3.set(seg, x);
-    }
-    public static int remember$get(MemorySegment seg, long index) {
-        return (int)constants$12.const$3.get(seg.asSlice(index*sizeof()));
+    public static void remember(MemorySegment struct, int fieldValue) {
+        struct.set(remember$LAYOUT, remember$OFFSET, fieldValue);
     }
-    public static void remember$set(MemorySegment seg, long index, int x) {
-        constants$12.const$3.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt hard_remove$LAYOUT = (OfInt)$LAYOUT.select(groupElement("hard_remove"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int hard_remove
+     * }
+     */
+    public static final OfInt hard_remove$layout() {
+        return hard_remove$LAYOUT;
     }
-    public static VarHandle hard_remove$VH() {
-        return constants$12.const$4;
+
+    private static final long hard_remove$OFFSET = 60;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int hard_remove
+     * }
+     */
+    public static final long hard_remove$offset() {
+        return hard_remove$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int hard_remove;
+     * {@snippet lang=c :
+     * int hard_remove
      * }
      */
-    public static int hard_remove$get(MemorySegment seg) {
-        return (int)constants$12.const$4.get(seg);
+    public static int hard_remove(MemorySegment struct) {
+        return struct.get(hard_remove$LAYOUT, hard_remove$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int hard_remove;
+     * {@snippet lang=c :
+     * int hard_remove
      * }
      */
-    public static void hard_remove$set(MemorySegment seg, int x) {
-        constants$12.const$4.set(seg, x);
-    }
-    public static int hard_remove$get(MemorySegment seg, long index) {
-        return (int)constants$12.const$4.get(seg.asSlice(index*sizeof()));
+    public static void hard_remove(MemorySegment struct, int fieldValue) {
+        struct.set(hard_remove$LAYOUT, hard_remove$OFFSET, fieldValue);
     }
-    public static void hard_remove$set(MemorySegment seg, long index, int x) {
-        constants$12.const$4.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt use_ino$LAYOUT = (OfInt)$LAYOUT.select(groupElement("use_ino"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int use_ino
+     * }
+     */
+    public static final OfInt use_ino$layout() {
+        return use_ino$LAYOUT;
     }
-    public static VarHandle use_ino$VH() {
-        return constants$12.const$5;
+
+    private static final long use_ino$OFFSET = 64;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int use_ino
+     * }
+     */
+    public static final long use_ino$offset() {
+        return use_ino$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int use_ino;
+     * {@snippet lang=c :
+     * int use_ino
      * }
      */
-    public static int use_ino$get(MemorySegment seg) {
-        return (int)constants$12.const$5.get(seg);
+    public static int use_ino(MemorySegment struct) {
+        return struct.get(use_ino$LAYOUT, use_ino$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int use_ino;
+     * {@snippet lang=c :
+     * int use_ino
      * }
      */
-    public static void use_ino$set(MemorySegment seg, int x) {
-        constants$12.const$5.set(seg, x);
-    }
-    public static int use_ino$get(MemorySegment seg, long index) {
-        return (int)constants$12.const$5.get(seg.asSlice(index*sizeof()));
+    public static void use_ino(MemorySegment struct, int fieldValue) {
+        struct.set(use_ino$LAYOUT, use_ino$OFFSET, fieldValue);
     }
-    public static void use_ino$set(MemorySegment seg, long index, int x) {
-        constants$12.const$5.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt readdir_ino$LAYOUT = (OfInt)$LAYOUT.select(groupElement("readdir_ino"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int readdir_ino
+     * }
+     */
+    public static final OfInt readdir_ino$layout() {
+        return readdir_ino$LAYOUT;
     }
-    public static VarHandle readdir_ino$VH() {
-        return constants$13.const$0;
+
+    private static final long readdir_ino$OFFSET = 68;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int readdir_ino
+     * }
+     */
+    public static final long readdir_ino$offset() {
+        return readdir_ino$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int readdir_ino;
+     * {@snippet lang=c :
+     * int readdir_ino
      * }
      */
-    public static int readdir_ino$get(MemorySegment seg) {
-        return (int)constants$13.const$0.get(seg);
+    public static int readdir_ino(MemorySegment struct) {
+        return struct.get(readdir_ino$LAYOUT, readdir_ino$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int readdir_ino;
+     * {@snippet lang=c :
+     * int readdir_ino
      * }
      */
-    public static void readdir_ino$set(MemorySegment seg, int x) {
-        constants$13.const$0.set(seg, x);
-    }
-    public static int readdir_ino$get(MemorySegment seg, long index) {
-        return (int)constants$13.const$0.get(seg.asSlice(index*sizeof()));
+    public static void readdir_ino(MemorySegment struct, int fieldValue) {
+        struct.set(readdir_ino$LAYOUT, readdir_ino$OFFSET, fieldValue);
     }
-    public static void readdir_ino$set(MemorySegment seg, long index, int x) {
-        constants$13.const$0.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt direct_io$LAYOUT = (OfInt)$LAYOUT.select(groupElement("direct_io"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int direct_io
+     * }
+     */
+    public static final OfInt direct_io$layout() {
+        return direct_io$LAYOUT;
     }
-    public static VarHandle direct_io$VH() {
-        return constants$13.const$1;
+
+    private static final long direct_io$OFFSET = 72;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int direct_io
+     * }
+     */
+    public static final long direct_io$offset() {
+        return direct_io$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int direct_io;
+     * {@snippet lang=c :
+     * int direct_io
      * }
      */
-    public static int direct_io$get(MemorySegment seg) {
-        return (int)constants$13.const$1.get(seg);
+    public static int direct_io(MemorySegment struct) {
+        return struct.get(direct_io$LAYOUT, direct_io$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int direct_io;
+     * {@snippet lang=c :
+     * int direct_io
      * }
      */
-    public static void direct_io$set(MemorySegment seg, int x) {
-        constants$13.const$1.set(seg, x);
+    public static void direct_io(MemorySegment struct, int fieldValue) {
+        struct.set(direct_io$LAYOUT, direct_io$OFFSET, fieldValue);
     }
-    public static int direct_io$get(MemorySegment seg, long index) {
-        return (int)constants$13.const$1.get(seg.asSlice(index*sizeof()));
-    }
-    public static void direct_io$set(MemorySegment seg, long index, int x) {
-        constants$13.const$1.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt kernel_cache$LAYOUT = (OfInt)$LAYOUT.select(groupElement("kernel_cache"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int kernel_cache
+     * }
+     */
+    public static final OfInt kernel_cache$layout() {
+        return kernel_cache$LAYOUT;
     }
-    public static VarHandle kernel_cache$VH() {
-        return constants$13.const$2;
+
+    private static final long kernel_cache$OFFSET = 76;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int kernel_cache
+     * }
+     */
+    public static final long kernel_cache$offset() {
+        return kernel_cache$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int kernel_cache;
+     * {@snippet lang=c :
+     * int kernel_cache
      * }
      */
-    public static int kernel_cache$get(MemorySegment seg) {
-        return (int)constants$13.const$2.get(seg);
+    public static int kernel_cache(MemorySegment struct) {
+        return struct.get(kernel_cache$LAYOUT, kernel_cache$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int kernel_cache;
+     * {@snippet lang=c :
+     * int kernel_cache
      * }
      */
-    public static void kernel_cache$set(MemorySegment seg, int x) {
-        constants$13.const$2.set(seg, x);
-    }
-    public static int kernel_cache$get(MemorySegment seg, long index) {
-        return (int)constants$13.const$2.get(seg.asSlice(index*sizeof()));
+    public static void kernel_cache(MemorySegment struct, int fieldValue) {
+        struct.set(kernel_cache$LAYOUT, kernel_cache$OFFSET, fieldValue);
     }
-    public static void kernel_cache$set(MemorySegment seg, long index, int x) {
-        constants$13.const$2.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt auto_cache$LAYOUT = (OfInt)$LAYOUT.select(groupElement("auto_cache"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int auto_cache
+     * }
+     */
+    public static final OfInt auto_cache$layout() {
+        return auto_cache$LAYOUT;
     }
-    public static VarHandle auto_cache$VH() {
-        return constants$13.const$3;
+
+    private static final long auto_cache$OFFSET = 80;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int auto_cache
+     * }
+     */
+    public static final long auto_cache$offset() {
+        return auto_cache$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int auto_cache;
+     * {@snippet lang=c :
+     * int auto_cache
      * }
      */
-    public static int auto_cache$get(MemorySegment seg) {
-        return (int)constants$13.const$3.get(seg);
+    public static int auto_cache(MemorySegment struct) {
+        return struct.get(auto_cache$LAYOUT, auto_cache$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int auto_cache;
+     * {@snippet lang=c :
+     * int auto_cache
      * }
      */
-    public static void auto_cache$set(MemorySegment seg, int x) {
-        constants$13.const$3.set(seg, x);
-    }
-    public static int auto_cache$get(MemorySegment seg, long index) {
-        return (int)constants$13.const$3.get(seg.asSlice(index*sizeof()));
+    public static void auto_cache(MemorySegment struct, int fieldValue) {
+        struct.set(auto_cache$LAYOUT, auto_cache$OFFSET, fieldValue);
     }
-    public static void auto_cache$set(MemorySegment seg, long index, int x) {
-        constants$13.const$3.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt no_rofd_flush$LAYOUT = (OfInt)$LAYOUT.select(groupElement("no_rofd_flush"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int no_rofd_flush
+     * }
+     */
+    public static final OfInt no_rofd_flush$layout() {
+        return no_rofd_flush$LAYOUT;
     }
-    public static VarHandle no_rofd_flush$VH() {
-        return constants$13.const$4;
+
+    private static final long no_rofd_flush$OFFSET = 84;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int no_rofd_flush
+     * }
+     */
+    public static final long no_rofd_flush$offset() {
+        return no_rofd_flush$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int no_rofd_flush;
+     * {@snippet lang=c :
+     * int no_rofd_flush
      * }
      */
-    public static int no_rofd_flush$get(MemorySegment seg) {
-        return (int)constants$13.const$4.get(seg);
+    public static int no_rofd_flush(MemorySegment struct) {
+        return struct.get(no_rofd_flush$LAYOUT, no_rofd_flush$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int no_rofd_flush;
+     * {@snippet lang=c :
+     * int no_rofd_flush
      * }
      */
-    public static void no_rofd_flush$set(MemorySegment seg, int x) {
-        constants$13.const$4.set(seg, x);
-    }
-    public static int no_rofd_flush$get(MemorySegment seg, long index) {
-        return (int)constants$13.const$4.get(seg.asSlice(index*sizeof()));
+    public static void no_rofd_flush(MemorySegment struct, int fieldValue) {
+        struct.set(no_rofd_flush$LAYOUT, no_rofd_flush$OFFSET, fieldValue);
     }
-    public static void no_rofd_flush$set(MemorySegment seg, long index, int x) {
-        constants$13.const$4.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt ac_attr_timeout_set$LAYOUT = (OfInt)$LAYOUT.select(groupElement("ac_attr_timeout_set"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int ac_attr_timeout_set
+     * }
+     */
+    public static final OfInt ac_attr_timeout_set$layout() {
+        return ac_attr_timeout_set$LAYOUT;
     }
-    public static VarHandle ac_attr_timeout_set$VH() {
-        return constants$13.const$5;
+
+    private static final long ac_attr_timeout_set$OFFSET = 88;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int ac_attr_timeout_set
+     * }
+     */
+    public static final long ac_attr_timeout_set$offset() {
+        return ac_attr_timeout_set$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int ac_attr_timeout_set;
+     * {@snippet lang=c :
+     * int ac_attr_timeout_set
      * }
      */
-    public static int ac_attr_timeout_set$get(MemorySegment seg) {
-        return (int)constants$13.const$5.get(seg);
+    public static int ac_attr_timeout_set(MemorySegment struct) {
+        return struct.get(ac_attr_timeout_set$LAYOUT, ac_attr_timeout_set$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int ac_attr_timeout_set;
+     * {@snippet lang=c :
+     * int ac_attr_timeout_set
      * }
      */
-    public static void ac_attr_timeout_set$set(MemorySegment seg, int x) {
-        constants$13.const$5.set(seg, x);
+    public static void ac_attr_timeout_set(MemorySegment struct, int fieldValue) {
+        struct.set(ac_attr_timeout_set$LAYOUT, ac_attr_timeout_set$OFFSET, fieldValue);
     }
-    public static int ac_attr_timeout_set$get(MemorySegment seg, long index) {
-        return (int)constants$13.const$5.get(seg.asSlice(index*sizeof()));
-    }
-    public static void ac_attr_timeout_set$set(MemorySegment seg, long index, int x) {
-        constants$13.const$5.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfDouble ac_attr_timeout$LAYOUT = (OfDouble)$LAYOUT.select(groupElement("ac_attr_timeout"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * double ac_attr_timeout
+     * }
+     */
+    public static final OfDouble ac_attr_timeout$layout() {
+        return ac_attr_timeout$LAYOUT;
     }
-    public static VarHandle ac_attr_timeout$VH() {
-        return constants$14.const$0;
+
+    private static final long ac_attr_timeout$OFFSET = 96;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * double ac_attr_timeout
+     * }
+     */
+    public static final long ac_attr_timeout$offset() {
+        return ac_attr_timeout$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * double ac_attr_timeout;
+     * {@snippet lang=c :
+     * double ac_attr_timeout
      * }
      */
-    public static double ac_attr_timeout$get(MemorySegment seg) {
-        return (double)constants$14.const$0.get(seg);
+    public static double ac_attr_timeout(MemorySegment struct) {
+        return struct.get(ac_attr_timeout$LAYOUT, ac_attr_timeout$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * double ac_attr_timeout;
+     * {@snippet lang=c :
+     * double ac_attr_timeout
      * }
      */
-    public static void ac_attr_timeout$set(MemorySegment seg, double x) {
-        constants$14.const$0.set(seg, x);
-    }
-    public static double ac_attr_timeout$get(MemorySegment seg, long index) {
-        return (double)constants$14.const$0.get(seg.asSlice(index*sizeof()));
+    public static void ac_attr_timeout(MemorySegment struct, double fieldValue) {
+        struct.set(ac_attr_timeout$LAYOUT, ac_attr_timeout$OFFSET, fieldValue);
     }
-    public static void ac_attr_timeout$set(MemorySegment seg, long index, double x) {
-        constants$14.const$0.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt nullpath_ok$LAYOUT = (OfInt)$LAYOUT.select(groupElement("nullpath_ok"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int nullpath_ok
+     * }
+     */
+    public static final OfInt nullpath_ok$layout() {
+        return nullpath_ok$LAYOUT;
     }
-    public static VarHandle nullpath_ok$VH() {
-        return constants$14.const$1;
+
+    private static final long nullpath_ok$OFFSET = 104;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int nullpath_ok
+     * }
+     */
+    public static final long nullpath_ok$offset() {
+        return nullpath_ok$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int nullpath_ok;
+     * {@snippet lang=c :
+     * int nullpath_ok
      * }
      */
-    public static int nullpath_ok$get(MemorySegment seg) {
-        return (int)constants$14.const$1.get(seg);
+    public static int nullpath_ok(MemorySegment struct) {
+        return struct.get(nullpath_ok$LAYOUT, nullpath_ok$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int nullpath_ok;
+     * {@snippet lang=c :
+     * int nullpath_ok
      * }
      */
-    public static void nullpath_ok$set(MemorySegment seg, int x) {
-        constants$14.const$1.set(seg, x);
+    public static void nullpath_ok(MemorySegment struct, int fieldValue) {
+        struct.set(nullpath_ok$LAYOUT, nullpath_ok$OFFSET, fieldValue);
     }
-    public static int nullpath_ok$get(MemorySegment seg, long index) {
-        return (int)constants$14.const$1.get(seg.asSlice(index*sizeof()));
-    }
-    public static void nullpath_ok$set(MemorySegment seg, long index, int x) {
-        constants$14.const$1.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt show_help$LAYOUT = (OfInt)$LAYOUT.select(groupElement("show_help"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int show_help
+     * }
+     */
+    public static final OfInt show_help$layout() {
+        return show_help$LAYOUT;
     }
-    public static VarHandle show_help$VH() {
-        return constants$14.const$2;
+
+    private static final long show_help$OFFSET = 108;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int show_help
+     * }
+     */
+    public static final long show_help$offset() {
+        return show_help$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int show_help;
+     * {@snippet lang=c :
+     * int show_help
      * }
      */
-    public static int show_help$get(MemorySegment seg) {
-        return (int)constants$14.const$2.get(seg);
+    public static int show_help(MemorySegment struct) {
+        return struct.get(show_help$LAYOUT, show_help$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int show_help;
+     * {@snippet lang=c :
+     * int show_help
      * }
      */
-    public static void show_help$set(MemorySegment seg, int x) {
-        constants$14.const$2.set(seg, x);
-    }
-    public static int show_help$get(MemorySegment seg, long index) {
-        return (int)constants$14.const$2.get(seg.asSlice(index*sizeof()));
+    public static void show_help(MemorySegment struct, int fieldValue) {
+        struct.set(show_help$LAYOUT, show_help$OFFSET, fieldValue);
     }
-    public static void show_help$set(MemorySegment seg, long index, int x) {
-        constants$14.const$2.set(seg.asSlice(index*sizeof()), x);
+
+    private static final AddressLayout modules$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("modules"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * char *modules
+     * }
+     */
+    public static final AddressLayout modules$layout() {
+        return modules$LAYOUT;
     }
-    public static VarHandle modules$VH() {
-        return constants$14.const$3;
+
+    private static final long modules$OFFSET = 112;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * char *modules
+     * }
+     */
+    public static final long modules$offset() {
+        return modules$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * char* modules;
+     * {@snippet lang=c :
+     * char *modules
      * }
      */
-    public static MemorySegment modules$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$14.const$3.get(seg);
+    public static MemorySegment modules(MemorySegment struct) {
+        return struct.get(modules$LAYOUT, modules$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * char* modules;
+     * {@snippet lang=c :
+     * char *modules
      * }
      */
-    public static void modules$set(MemorySegment seg, MemorySegment x) {
-        constants$14.const$3.set(seg, x);
-    }
-    public static MemorySegment modules$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$14.const$3.get(seg.asSlice(index*sizeof()));
+    public static void modules(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(modules$LAYOUT, modules$OFFSET, fieldValue);
     }
-    public static void modules$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$14.const$3.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt debug$LAYOUT = (OfInt)$LAYOUT.select(groupElement("debug"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int debug
+     * }
+     */
+    public static final OfInt debug$layout() {
+        return debug$LAYOUT;
     }
-    public static VarHandle debug$VH() {
-        return constants$14.const$4;
+
+    private static final long debug$OFFSET = 120;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int debug
+     * }
+     */
+    public static final long debug$offset() {
+        return debug$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int debug;
+     * {@snippet lang=c :
+     * int debug
      * }
      */
-    public static int debug$get(MemorySegment seg) {
-        return (int)constants$14.const$4.get(seg);
+    public static int debug(MemorySegment struct) {
+        return struct.get(debug$LAYOUT, debug$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int debug;
+     * {@snippet lang=c :
+     * int debug
      * }
      */
-    public static void debug$set(MemorySegment seg, int x) {
-        constants$14.const$4.set(seg, x);
+    public static void debug(MemorySegment struct, int fieldValue) {
+        struct.set(debug$LAYOUT, debug$OFFSET, fieldValue);
+    }
+
+    /**
+     * Obtains a slice of {@code arrayParam} which selects the array element at {@code index}.
+     * The returned segment has address {@code arrayParam.address() + index * layout().byteSize()}
+     */
+    public static MemorySegment asSlice(MemorySegment array, long index) {
+        return array.asSlice(layout().byteSize() * index);
+    }
+
+    /**
+     * The size (in bytes) of this struct
+     */
+    public static long sizeof() { return layout().byteSize(); }
+
+    /**
+     * Allocate a segment of size {@code layout().byteSize()} using {@code allocator}
+     */
+    public static MemorySegment allocate(SegmentAllocator allocator) {
+        return allocator.allocate(layout());
     }
-    public static int debug$get(MemorySegment seg, long index) {
-        return (int)constants$14.const$4.get(seg.asSlice(index*sizeof()));
+
+    /**
+     * Allocate an array of size {@code elementCount} using {@code allocator}.
+     * The returned segment has size {@code elementCount * layout().byteSize()}.
+     */
+    public static MemorySegment allocateArray(long elementCount, SegmentAllocator allocator) {
+        return allocator.allocate(MemoryLayout.sequenceLayout(elementCount, layout()));
     }
-    public static void debug$set(MemorySegment seg, long index, int x) {
-        constants$14.const$4.set(seg.asSlice(index*sizeof()), x);
+
+    /**
+     * Reinterprets {@code addr} using target {@code arena} and {@code cleanupAction) (if any).
+     * The returned segment has size {@code layout().byteSize()}
+     */
+    public static MemorySegment reinterpret(MemorySegment addr, Arena arena, Consumer<MemorySegment> cleanup) {
+        return reinterpret(addr, 1, arena, cleanup);
     }
-    public static long sizeof() { return $LAYOUT().byteSize(); }
-    public static MemorySegment allocate(SegmentAllocator allocator) { return allocator.allocate($LAYOUT()); }
-    public static MemorySegment allocateArray(long len, SegmentAllocator allocator) {
-        return allocator.allocate(MemoryLayout.sequenceLayout(len, $LAYOUT()));
+
+    /**
+     * Reinterprets {@code addr} using target {@code arena} and {@code cleanupAction) (if any).
+     * The returned segment has size {@code elementCount * layout().byteSize()}
+     */
+    public static MemorySegment reinterpret(MemorySegment addr, long elementCount, Arena arena, Consumer<MemorySegment> cleanup) {
+        return addr.reinterpret(layout().byteSize() * elementCount, arena, cleanup);
     }
-    public static MemorySegment ofAddress(MemorySegment addr, Arena scope) { return RuntimeHelper.asArray(addr, $LAYOUT(), 1, scope); }
 }
 
-
diff --git a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/fuse_conn_info.java b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/fuse_conn_info.java
index c09c54e8..b826e848 100644
--- a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/fuse_conn_info.java
+++ b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/fuse_conn_info.java
@@ -2,13 +2,18 @@
 
 package org.cryptomator.jfuse.linux.aarch64.extr.fuse3;
 
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
+import java.lang.invoke.*;
 import java.lang.foreign.*;
+import java.nio.ByteOrder;
+import java.util.*;
+import java.util.function.*;
+import java.util.stream.*;
+
 import static java.lang.foreign.ValueLayout.*;
+import static java.lang.foreign.MemoryLayout.PathElement.*;
+
 /**
- * {@snippet :
+ * {@snippet lang=c :
  * struct fuse_conn_info {
  *     unsigned int proto_major;
  *     unsigned int proto_minor;
@@ -21,293 +26,595 @@
  *     unsigned int congestion_threshold;
  *     unsigned int time_gran;
  *     unsigned int reserved[22];
- * };
+ * }
  * }
  */
 public class fuse_conn_info {
 
-    public static MemoryLayout $LAYOUT() {
-        return constants$2.const$3;
+    fuse_conn_info() {
+        // Should not be called directly
     }
-    public static VarHandle proto_major$VH() {
-        return constants$2.const$4;
+
+    private static final GroupLayout $LAYOUT = MemoryLayout.structLayout(
+        fuse_h.C_INT.withName("proto_major"),
+        fuse_h.C_INT.withName("proto_minor"),
+        fuse_h.C_INT.withName("max_write"),
+        fuse_h.C_INT.withName("max_read"),
+        fuse_h.C_INT.withName("max_readahead"),
+        fuse_h.C_INT.withName("capable"),
+        fuse_h.C_INT.withName("want"),
+        fuse_h.C_INT.withName("max_background"),
+        fuse_h.C_INT.withName("congestion_threshold"),
+        fuse_h.C_INT.withName("time_gran"),
+        MemoryLayout.sequenceLayout(22, fuse_h.C_INT).withName("reserved")
+    ).withName("fuse_conn_info");
+
+    /**
+     * The layout of this struct
+     */
+    public static final GroupLayout layout() {
+        return $LAYOUT;
     }
+
+    private static final OfInt proto_major$LAYOUT = (OfInt)$LAYOUT.select(groupElement("proto_major"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * unsigned int proto_major
+     * }
+     */
+    public static final OfInt proto_major$layout() {
+        return proto_major$LAYOUT;
+    }
+
+    private static final long proto_major$OFFSET = 0;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * unsigned int proto_major
+     * }
+     */
+    public static final long proto_major$offset() {
+        return proto_major$OFFSET;
+    }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned int proto_major;
+     * {@snippet lang=c :
+     * unsigned int proto_major
      * }
      */
-    public static int proto_major$get(MemorySegment seg) {
-        return (int)constants$2.const$4.get(seg);
+    public static int proto_major(MemorySegment struct) {
+        return struct.get(proto_major$LAYOUT, proto_major$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned int proto_major;
+     * {@snippet lang=c :
+     * unsigned int proto_major
      * }
      */
-    public static void proto_major$set(MemorySegment seg, int x) {
-        constants$2.const$4.set(seg, x);
-    }
-    public static int proto_major$get(MemorySegment seg, long index) {
-        return (int)constants$2.const$4.get(seg.asSlice(index*sizeof()));
+    public static void proto_major(MemorySegment struct, int fieldValue) {
+        struct.set(proto_major$LAYOUT, proto_major$OFFSET, fieldValue);
     }
-    public static void proto_major$set(MemorySegment seg, long index, int x) {
-        constants$2.const$4.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt proto_minor$LAYOUT = (OfInt)$LAYOUT.select(groupElement("proto_minor"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * unsigned int proto_minor
+     * }
+     */
+    public static final OfInt proto_minor$layout() {
+        return proto_minor$LAYOUT;
     }
-    public static VarHandle proto_minor$VH() {
-        return constants$2.const$5;
+
+    private static final long proto_minor$OFFSET = 4;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * unsigned int proto_minor
+     * }
+     */
+    public static final long proto_minor$offset() {
+        return proto_minor$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned int proto_minor;
+     * {@snippet lang=c :
+     * unsigned int proto_minor
      * }
      */
-    public static int proto_minor$get(MemorySegment seg) {
-        return (int)constants$2.const$5.get(seg);
+    public static int proto_minor(MemorySegment struct) {
+        return struct.get(proto_minor$LAYOUT, proto_minor$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned int proto_minor;
+     * {@snippet lang=c :
+     * unsigned int proto_minor
      * }
      */
-    public static void proto_minor$set(MemorySegment seg, int x) {
-        constants$2.const$5.set(seg, x);
-    }
-    public static int proto_minor$get(MemorySegment seg, long index) {
-        return (int)constants$2.const$5.get(seg.asSlice(index*sizeof()));
+    public static void proto_minor(MemorySegment struct, int fieldValue) {
+        struct.set(proto_minor$LAYOUT, proto_minor$OFFSET, fieldValue);
     }
-    public static void proto_minor$set(MemorySegment seg, long index, int x) {
-        constants$2.const$5.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt max_write$LAYOUT = (OfInt)$LAYOUT.select(groupElement("max_write"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * unsigned int max_write
+     * }
+     */
+    public static final OfInt max_write$layout() {
+        return max_write$LAYOUT;
     }
-    public static VarHandle max_write$VH() {
-        return constants$3.const$0;
+
+    private static final long max_write$OFFSET = 8;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * unsigned int max_write
+     * }
+     */
+    public static final long max_write$offset() {
+        return max_write$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned int max_write;
+     * {@snippet lang=c :
+     * unsigned int max_write
      * }
      */
-    public static int max_write$get(MemorySegment seg) {
-        return (int)constants$3.const$0.get(seg);
+    public static int max_write(MemorySegment struct) {
+        return struct.get(max_write$LAYOUT, max_write$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned int max_write;
+     * {@snippet lang=c :
+     * unsigned int max_write
      * }
      */
-    public static void max_write$set(MemorySegment seg, int x) {
-        constants$3.const$0.set(seg, x);
-    }
-    public static int max_write$get(MemorySegment seg, long index) {
-        return (int)constants$3.const$0.get(seg.asSlice(index*sizeof()));
+    public static void max_write(MemorySegment struct, int fieldValue) {
+        struct.set(max_write$LAYOUT, max_write$OFFSET, fieldValue);
     }
-    public static void max_write$set(MemorySegment seg, long index, int x) {
-        constants$3.const$0.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt max_read$LAYOUT = (OfInt)$LAYOUT.select(groupElement("max_read"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * unsigned int max_read
+     * }
+     */
+    public static final OfInt max_read$layout() {
+        return max_read$LAYOUT;
     }
-    public static VarHandle max_read$VH() {
-        return constants$3.const$1;
+
+    private static final long max_read$OFFSET = 12;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * unsigned int max_read
+     * }
+     */
+    public static final long max_read$offset() {
+        return max_read$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned int max_read;
+     * {@snippet lang=c :
+     * unsigned int max_read
      * }
      */
-    public static int max_read$get(MemorySegment seg) {
-        return (int)constants$3.const$1.get(seg);
+    public static int max_read(MemorySegment struct) {
+        return struct.get(max_read$LAYOUT, max_read$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned int max_read;
+     * {@snippet lang=c :
+     * unsigned int max_read
      * }
      */
-    public static void max_read$set(MemorySegment seg, int x) {
-        constants$3.const$1.set(seg, x);
-    }
-    public static int max_read$get(MemorySegment seg, long index) {
-        return (int)constants$3.const$1.get(seg.asSlice(index*sizeof()));
+    public static void max_read(MemorySegment struct, int fieldValue) {
+        struct.set(max_read$LAYOUT, max_read$OFFSET, fieldValue);
     }
-    public static void max_read$set(MemorySegment seg, long index, int x) {
-        constants$3.const$1.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt max_readahead$LAYOUT = (OfInt)$LAYOUT.select(groupElement("max_readahead"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * unsigned int max_readahead
+     * }
+     */
+    public static final OfInt max_readahead$layout() {
+        return max_readahead$LAYOUT;
     }
-    public static VarHandle max_readahead$VH() {
-        return constants$3.const$2;
+
+    private static final long max_readahead$OFFSET = 16;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * unsigned int max_readahead
+     * }
+     */
+    public static final long max_readahead$offset() {
+        return max_readahead$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned int max_readahead;
+     * {@snippet lang=c :
+     * unsigned int max_readahead
      * }
      */
-    public static int max_readahead$get(MemorySegment seg) {
-        return (int)constants$3.const$2.get(seg);
+    public static int max_readahead(MemorySegment struct) {
+        return struct.get(max_readahead$LAYOUT, max_readahead$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned int max_readahead;
+     * {@snippet lang=c :
+     * unsigned int max_readahead
      * }
      */
-    public static void max_readahead$set(MemorySegment seg, int x) {
-        constants$3.const$2.set(seg, x);
+    public static void max_readahead(MemorySegment struct, int fieldValue) {
+        struct.set(max_readahead$LAYOUT, max_readahead$OFFSET, fieldValue);
     }
-    public static int max_readahead$get(MemorySegment seg, long index) {
-        return (int)constants$3.const$2.get(seg.asSlice(index*sizeof()));
-    }
-    public static void max_readahead$set(MemorySegment seg, long index, int x) {
-        constants$3.const$2.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt capable$LAYOUT = (OfInt)$LAYOUT.select(groupElement("capable"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * unsigned int capable
+     * }
+     */
+    public static final OfInt capable$layout() {
+        return capable$LAYOUT;
     }
-    public static VarHandle capable$VH() {
-        return constants$3.const$3;
+
+    private static final long capable$OFFSET = 20;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * unsigned int capable
+     * }
+     */
+    public static final long capable$offset() {
+        return capable$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned int capable;
+     * {@snippet lang=c :
+     * unsigned int capable
      * }
      */
-    public static int capable$get(MemorySegment seg) {
-        return (int)constants$3.const$3.get(seg);
+    public static int capable(MemorySegment struct) {
+        return struct.get(capable$LAYOUT, capable$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned int capable;
+     * {@snippet lang=c :
+     * unsigned int capable
      * }
      */
-    public static void capable$set(MemorySegment seg, int x) {
-        constants$3.const$3.set(seg, x);
-    }
-    public static int capable$get(MemorySegment seg, long index) {
-        return (int)constants$3.const$3.get(seg.asSlice(index*sizeof()));
+    public static void capable(MemorySegment struct, int fieldValue) {
+        struct.set(capable$LAYOUT, capable$OFFSET, fieldValue);
     }
-    public static void capable$set(MemorySegment seg, long index, int x) {
-        constants$3.const$3.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt want$LAYOUT = (OfInt)$LAYOUT.select(groupElement("want"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * unsigned int want
+     * }
+     */
+    public static final OfInt want$layout() {
+        return want$LAYOUT;
     }
-    public static VarHandle want$VH() {
-        return constants$3.const$4;
+
+    private static final long want$OFFSET = 24;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * unsigned int want
+     * }
+     */
+    public static final long want$offset() {
+        return want$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned int want;
+     * {@snippet lang=c :
+     * unsigned int want
      * }
      */
-    public static int want$get(MemorySegment seg) {
-        return (int)constants$3.const$4.get(seg);
+    public static int want(MemorySegment struct) {
+        return struct.get(want$LAYOUT, want$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned int want;
+     * {@snippet lang=c :
+     * unsigned int want
      * }
      */
-    public static void want$set(MemorySegment seg, int x) {
-        constants$3.const$4.set(seg, x);
+    public static void want(MemorySegment struct, int fieldValue) {
+        struct.set(want$LAYOUT, want$OFFSET, fieldValue);
     }
-    public static int want$get(MemorySegment seg, long index) {
-        return (int)constants$3.const$4.get(seg.asSlice(index*sizeof()));
-    }
-    public static void want$set(MemorySegment seg, long index, int x) {
-        constants$3.const$4.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt max_background$LAYOUT = (OfInt)$LAYOUT.select(groupElement("max_background"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * unsigned int max_background
+     * }
+     */
+    public static final OfInt max_background$layout() {
+        return max_background$LAYOUT;
     }
-    public static VarHandle max_background$VH() {
-        return constants$3.const$5;
+
+    private static final long max_background$OFFSET = 28;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * unsigned int max_background
+     * }
+     */
+    public static final long max_background$offset() {
+        return max_background$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned int max_background;
+     * {@snippet lang=c :
+     * unsigned int max_background
      * }
      */
-    public static int max_background$get(MemorySegment seg) {
-        return (int)constants$3.const$5.get(seg);
+    public static int max_background(MemorySegment struct) {
+        return struct.get(max_background$LAYOUT, max_background$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned int max_background;
+     * {@snippet lang=c :
+     * unsigned int max_background
      * }
      */
-    public static void max_background$set(MemorySegment seg, int x) {
-        constants$3.const$5.set(seg, x);
-    }
-    public static int max_background$get(MemorySegment seg, long index) {
-        return (int)constants$3.const$5.get(seg.asSlice(index*sizeof()));
+    public static void max_background(MemorySegment struct, int fieldValue) {
+        struct.set(max_background$LAYOUT, max_background$OFFSET, fieldValue);
     }
-    public static void max_background$set(MemorySegment seg, long index, int x) {
-        constants$3.const$5.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt congestion_threshold$LAYOUT = (OfInt)$LAYOUT.select(groupElement("congestion_threshold"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * unsigned int congestion_threshold
+     * }
+     */
+    public static final OfInt congestion_threshold$layout() {
+        return congestion_threshold$LAYOUT;
     }
-    public static VarHandle congestion_threshold$VH() {
-        return constants$4.const$0;
+
+    private static final long congestion_threshold$OFFSET = 32;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * unsigned int congestion_threshold
+     * }
+     */
+    public static final long congestion_threshold$offset() {
+        return congestion_threshold$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned int congestion_threshold;
+     * {@snippet lang=c :
+     * unsigned int congestion_threshold
      * }
      */
-    public static int congestion_threshold$get(MemorySegment seg) {
-        return (int)constants$4.const$0.get(seg);
+    public static int congestion_threshold(MemorySegment struct) {
+        return struct.get(congestion_threshold$LAYOUT, congestion_threshold$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned int congestion_threshold;
+     * {@snippet lang=c :
+     * unsigned int congestion_threshold
      * }
      */
-    public static void congestion_threshold$set(MemorySegment seg, int x) {
-        constants$4.const$0.set(seg, x);
+    public static void congestion_threshold(MemorySegment struct, int fieldValue) {
+        struct.set(congestion_threshold$LAYOUT, congestion_threshold$OFFSET, fieldValue);
     }
-    public static int congestion_threshold$get(MemorySegment seg, long index) {
-        return (int)constants$4.const$0.get(seg.asSlice(index*sizeof()));
+
+    private static final OfInt time_gran$LAYOUT = (OfInt)$LAYOUT.select(groupElement("time_gran"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * unsigned int time_gran
+     * }
+     */
+    public static final OfInt time_gran$layout() {
+        return time_gran$LAYOUT;
     }
-    public static void congestion_threshold$set(MemorySegment seg, long index, int x) {
-        constants$4.const$0.set(seg.asSlice(index*sizeof()), x);
+
+    private static final long time_gran$OFFSET = 36;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * unsigned int time_gran
+     * }
+     */
+    public static final long time_gran$offset() {
+        return time_gran$OFFSET;
     }
-    public static VarHandle time_gran$VH() {
-        return constants$4.const$1;
+
+    /**
+     * Getter for field:
+     * {@snippet lang=c :
+     * unsigned int time_gran
+     * }
+     */
+    public static int time_gran(MemorySegment struct) {
+        return struct.get(time_gran$LAYOUT, time_gran$OFFSET);
     }
+
+    /**
+     * Setter for field:
+     * {@snippet lang=c :
+     * unsigned int time_gran
+     * }
+     */
+    public static void time_gran(MemorySegment struct, int fieldValue) {
+        struct.set(time_gran$LAYOUT, time_gran$OFFSET, fieldValue);
+    }
+
+    private static final SequenceLayout reserved$LAYOUT = (SequenceLayout)$LAYOUT.select(groupElement("reserved"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * unsigned int reserved[22]
+     * }
+     */
+    public static final SequenceLayout reserved$layout() {
+        return reserved$LAYOUT;
+    }
+
+    private static final long reserved$OFFSET = 40;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * unsigned int reserved[22]
+     * }
+     */
+    public static final long reserved$offset() {
+        return reserved$OFFSET;
+    }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned int time_gran;
+     * {@snippet lang=c :
+     * unsigned int reserved[22]
      * }
      */
-    public static int time_gran$get(MemorySegment seg) {
-        return (int)constants$4.const$1.get(seg);
+    public static MemorySegment reserved(MemorySegment struct) {
+        return struct.asSlice(reserved$OFFSET, reserved$LAYOUT.byteSize());
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned int time_gran;
+     * {@snippet lang=c :
+     * unsigned int reserved[22]
      * }
      */
-    public static void time_gran$set(MemorySegment seg, int x) {
-        constants$4.const$1.set(seg, x);
+    public static void reserved(MemorySegment struct, MemorySegment fieldValue) {
+        MemorySegment.copy(fieldValue, 0L, struct, reserved$OFFSET, reserved$LAYOUT.byteSize());
     }
-    public static int time_gran$get(MemorySegment seg, long index) {
-        return (int)constants$4.const$1.get(seg.asSlice(index*sizeof()));
+
+    private static long[] reserved$DIMS = { 22 };
+
+    /**
+     * Dimensions for array field:
+     * {@snippet lang=c :
+     * unsigned int reserved[22]
+     * }
+     */
+    public static long[] reserved$dimensions() {
+        return reserved$DIMS;
     }
-    public static void time_gran$set(MemorySegment seg, long index, int x) {
-        constants$4.const$1.set(seg.asSlice(index*sizeof()), x);
+    private static final VarHandle reserved$ELEM_HANDLE = reserved$LAYOUT.varHandle(sequenceElement());
+
+    /**
+     * Indexed getter for field:
+     * {@snippet lang=c :
+     * unsigned int reserved[22]
+     * }
+     */
+    public static int reserved(MemorySegment struct, long index0) {
+        return (int)reserved$ELEM_HANDLE.get(struct, 0L, index0);
     }
-    public static MemorySegment reserved$slice(MemorySegment seg) {
-        return seg.asSlice(40, 88);
+
+    /**
+     * Indexed setter for field:
+     * {@snippet lang=c :
+     * unsigned int reserved[22]
+     * }
+     */
+    public static void reserved(MemorySegment struct, long index0, int fieldValue) {
+        reserved$ELEM_HANDLE.set(struct, 0L, index0, fieldValue);
     }
-    public static long sizeof() { return $LAYOUT().byteSize(); }
-    public static MemorySegment allocate(SegmentAllocator allocator) { return allocator.allocate($LAYOUT()); }
-    public static MemorySegment allocateArray(long len, SegmentAllocator allocator) {
-        return allocator.allocate(MemoryLayout.sequenceLayout(len, $LAYOUT()));
+
+    /**
+     * Obtains a slice of {@code arrayParam} which selects the array element at {@code index}.
+     * The returned segment has address {@code arrayParam.address() + index * layout().byteSize()}
+     */
+    public static MemorySegment asSlice(MemorySegment array, long index) {
+        return array.asSlice(layout().byteSize() * index);
+    }
+
+    /**
+     * The size (in bytes) of this struct
+     */
+    public static long sizeof() { return layout().byteSize(); }
+
+    /**
+     * Allocate a segment of size {@code layout().byteSize()} using {@code allocator}
+     */
+    public static MemorySegment allocate(SegmentAllocator allocator) {
+        return allocator.allocate(layout());
     }
-    public static MemorySegment ofAddress(MemorySegment addr, Arena scope) { return RuntimeHelper.asArray(addr, $LAYOUT(), 1, scope); }
-}
 
+    /**
+     * Allocate an array of size {@code elementCount} using {@code allocator}.
+     * The returned segment has size {@code elementCount * layout().byteSize()}.
+     */
+    public static MemorySegment allocateArray(long elementCount, SegmentAllocator allocator) {
+        return allocator.allocate(MemoryLayout.sequenceLayout(elementCount, layout()));
+    }
+
+    /**
+     * Reinterprets {@code addr} using target {@code arena} and {@code cleanupAction) (if any).
+     * The returned segment has size {@code layout().byteSize()}
+     */
+    public static MemorySegment reinterpret(MemorySegment addr, Arena arena, Consumer<MemorySegment> cleanup) {
+        return reinterpret(addr, 1, arena, cleanup);
+    }
+
+    /**
+     * Reinterprets {@code addr} using target {@code arena} and {@code cleanupAction) (if any).
+     * The returned segment has size {@code elementCount * layout().byteSize()}
+     */
+    public static MemorySegment reinterpret(MemorySegment addr, long elementCount, Arena arena, Consumer<MemorySegment> cleanup) {
+        return addr.reinterpret(layout().byteSize() * elementCount, arena, cleanup);
+    }
+}
 
diff --git a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/fuse_file_info.java b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/fuse_file_info.java
index c70836fb..ce83677a 100644
--- a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/fuse_file_info.java
+++ b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/fuse_file_info.java
@@ -2,150 +2,276 @@
 
 package org.cryptomator.jfuse.linux.aarch64.extr.fuse3;
 
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
+import java.lang.invoke.*;
 import java.lang.foreign.*;
+import java.nio.ByteOrder;
+import java.util.*;
+import java.util.function.*;
+import java.util.stream.*;
+
 import static java.lang.foreign.ValueLayout.*;
+import static java.lang.foreign.MemoryLayout.PathElement.*;
+
 /**
- * {@snippet :
+ * {@snippet lang=c :
  * struct fuse_file_info {
  *     int flags;
- *      *     unsigned int writepage;
- *     unsigned int direct_io;
- *     unsigned int keep_cache;
- *     unsigned int flush;
- *     unsigned int nonseekable;
- *     unsigned int flock_release;
- *     unsigned int cache_readdir;
- *     unsigned int noflush;
- *     unsigned int padding;
- *     unsigned int padding2;
- *     unsigned long fh;
- *     unsigned long lock_owner;
- *     unsigned int poll_events;
- * };
+ *     unsigned int writepage : 1;
+ *     unsigned int direct_io : 1;
+ *     unsigned int keep_cache : 1;
+ *     unsigned int flush : 1;
+ *     unsigned int nonseekable : 1;
+ *     unsigned int flock_release : 1;
+ *     unsigned int cache_readdir : 1;
+ *     unsigned int noflush : 1;
+ *     unsigned int padding : 24;
+ *     unsigned int padding2 : 32;
+ *     uint64_t fh;
+ *     uint64_t lock_owner;
+ *     uint32_t poll_events;
+ * }
  * }
  */
 public class fuse_file_info {
 
-    public static MemoryLayout $LAYOUT() {
-        return constants$1.const$1;
+    fuse_file_info() {
+        // Should not be called directly
     }
-    public static VarHandle flags$VH() {
-        return constants$1.const$2;
+
+    private static final GroupLayout $LAYOUT = MemoryLayout.structLayout(
+        fuse_h.C_INT.withName("flags"),
+        MemoryLayout.paddingLayout(12),
+        fuse_h.C_LONG.withName("fh"),
+        fuse_h.C_LONG.withName("lock_owner"),
+        fuse_h.C_INT.withName("poll_events"),
+        MemoryLayout.paddingLayout(4)
+    ).withName("fuse_file_info");
+
+    /**
+     * The layout of this struct
+     */
+    public static final GroupLayout layout() {
+        return $LAYOUT;
+    }
+
+    private static final OfInt flags$LAYOUT = (OfInt)$LAYOUT.select(groupElement("flags"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int flags
+     * }
+     */
+    public static final OfInt flags$layout() {
+        return flags$LAYOUT;
+    }
+
+    private static final long flags$OFFSET = 0;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int flags
+     * }
+     */
+    public static final long flags$offset() {
+        return flags$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int flags;
+     * {@snippet lang=c :
+     * int flags
      * }
      */
-    public static int flags$get(MemorySegment seg) {
-        return (int)constants$1.const$2.get(seg);
+    public static int flags(MemorySegment struct) {
+        return struct.get(flags$LAYOUT, flags$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int flags;
+     * {@snippet lang=c :
+     * int flags
      * }
      */
-    public static void flags$set(MemorySegment seg, int x) {
-        constants$1.const$2.set(seg, x);
-    }
-    public static int flags$get(MemorySegment seg, long index) {
-        return (int)constants$1.const$2.get(seg.asSlice(index*sizeof()));
+    public static void flags(MemorySegment struct, int fieldValue) {
+        struct.set(flags$LAYOUT, flags$OFFSET, fieldValue);
     }
-    public static void flags$set(MemorySegment seg, long index, int x) {
-        constants$1.const$2.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfLong fh$LAYOUT = (OfLong)$LAYOUT.select(groupElement("fh"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * uint64_t fh
+     * }
+     */
+    public static final OfLong fh$layout() {
+        return fh$LAYOUT;
     }
-    public static VarHandle fh$VH() {
-        return constants$1.const$3;
+
+    private static final long fh$OFFSET = 16;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * uint64_t fh
+     * }
+     */
+    public static final long fh$offset() {
+        return fh$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned long fh;
+     * {@snippet lang=c :
+     * uint64_t fh
      * }
      */
-    public static long fh$get(MemorySegment seg) {
-        return (long)constants$1.const$3.get(seg);
+    public static long fh(MemorySegment struct) {
+        return struct.get(fh$LAYOUT, fh$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned long fh;
+     * {@snippet lang=c :
+     * uint64_t fh
      * }
      */
-    public static void fh$set(MemorySegment seg, long x) {
-        constants$1.const$3.set(seg, x);
-    }
-    public static long fh$get(MemorySegment seg, long index) {
-        return (long)constants$1.const$3.get(seg.asSlice(index*sizeof()));
+    public static void fh(MemorySegment struct, long fieldValue) {
+        struct.set(fh$LAYOUT, fh$OFFSET, fieldValue);
     }
-    public static void fh$set(MemorySegment seg, long index, long x) {
-        constants$1.const$3.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfLong lock_owner$LAYOUT = (OfLong)$LAYOUT.select(groupElement("lock_owner"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * uint64_t lock_owner
+     * }
+     */
+    public static final OfLong lock_owner$layout() {
+        return lock_owner$LAYOUT;
     }
-    public static VarHandle lock_owner$VH() {
-        return constants$1.const$4;
+
+    private static final long lock_owner$OFFSET = 24;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * uint64_t lock_owner
+     * }
+     */
+    public static final long lock_owner$offset() {
+        return lock_owner$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned long lock_owner;
+     * {@snippet lang=c :
+     * uint64_t lock_owner
      * }
      */
-    public static long lock_owner$get(MemorySegment seg) {
-        return (long)constants$1.const$4.get(seg);
+    public static long lock_owner(MemorySegment struct) {
+        return struct.get(lock_owner$LAYOUT, lock_owner$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned long lock_owner;
+     * {@snippet lang=c :
+     * uint64_t lock_owner
      * }
      */
-    public static void lock_owner$set(MemorySegment seg, long x) {
-        constants$1.const$4.set(seg, x);
-    }
-    public static long lock_owner$get(MemorySegment seg, long index) {
-        return (long)constants$1.const$4.get(seg.asSlice(index*sizeof()));
+    public static void lock_owner(MemorySegment struct, long fieldValue) {
+        struct.set(lock_owner$LAYOUT, lock_owner$OFFSET, fieldValue);
     }
-    public static void lock_owner$set(MemorySegment seg, long index, long x) {
-        constants$1.const$4.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt poll_events$LAYOUT = (OfInt)$LAYOUT.select(groupElement("poll_events"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * uint32_t poll_events
+     * }
+     */
+    public static final OfInt poll_events$layout() {
+        return poll_events$LAYOUT;
     }
-    public static VarHandle poll_events$VH() {
-        return constants$1.const$5;
+
+    private static final long poll_events$OFFSET = 32;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * uint32_t poll_events
+     * }
+     */
+    public static final long poll_events$offset() {
+        return poll_events$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned int poll_events;
+     * {@snippet lang=c :
+     * uint32_t poll_events
      * }
      */
-    public static int poll_events$get(MemorySegment seg) {
-        return (int)constants$1.const$5.get(seg);
+    public static int poll_events(MemorySegment struct) {
+        return struct.get(poll_events$LAYOUT, poll_events$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned int poll_events;
+     * {@snippet lang=c :
+     * uint32_t poll_events
      * }
      */
-    public static void poll_events$set(MemorySegment seg, int x) {
-        constants$1.const$5.set(seg, x);
+    public static void poll_events(MemorySegment struct, int fieldValue) {
+        struct.set(poll_events$LAYOUT, poll_events$OFFSET, fieldValue);
     }
-    public static int poll_events$get(MemorySegment seg, long index) {
-        return (int)constants$1.const$5.get(seg.asSlice(index*sizeof()));
+
+    /**
+     * Obtains a slice of {@code arrayParam} which selects the array element at {@code index}.
+     * The returned segment has address {@code arrayParam.address() + index * layout().byteSize()}
+     */
+    public static MemorySegment asSlice(MemorySegment array, long index) {
+        return array.asSlice(layout().byteSize() * index);
+    }
+
+    /**
+     * The size (in bytes) of this struct
+     */
+    public static long sizeof() { return layout().byteSize(); }
+
+    /**
+     * Allocate a segment of size {@code layout().byteSize()} using {@code allocator}
+     */
+    public static MemorySegment allocate(SegmentAllocator allocator) {
+        return allocator.allocate(layout());
+    }
+
+    /**
+     * Allocate an array of size {@code elementCount} using {@code allocator}.
+     * The returned segment has size {@code elementCount * layout().byteSize()}.
+     */
+    public static MemorySegment allocateArray(long elementCount, SegmentAllocator allocator) {
+        return allocator.allocate(MemoryLayout.sequenceLayout(elementCount, layout()));
     }
-    public static void poll_events$set(MemorySegment seg, long index, int x) {
-        constants$1.const$5.set(seg.asSlice(index*sizeof()), x);
+
+    /**
+     * Reinterprets {@code addr} using target {@code arena} and {@code cleanupAction) (if any).
+     * The returned segment has size {@code layout().byteSize()}
+     */
+    public static MemorySegment reinterpret(MemorySegment addr, Arena arena, Consumer<MemorySegment> cleanup) {
+        return reinterpret(addr, 1, arena, cleanup);
     }
-    public static long sizeof() { return $LAYOUT().byteSize(); }
-    public static MemorySegment allocate(SegmentAllocator allocator) { return allocator.allocate($LAYOUT()); }
-    public static MemorySegment allocateArray(long len, SegmentAllocator allocator) {
-        return allocator.allocate(MemoryLayout.sequenceLayout(len, $LAYOUT()));
+
+    /**
+     * Reinterprets {@code addr} using target {@code arena} and {@code cleanupAction) (if any).
+     * The returned segment has size {@code elementCount * layout().byteSize()}
+     */
+    public static MemorySegment reinterpret(MemorySegment addr, long elementCount, Arena arena, Consumer<MemorySegment> cleanup) {
+        return addr.reinterpret(layout().byteSize() * elementCount, arena, cleanup);
     }
-    public static MemorySegment ofAddress(MemorySegment addr, Arena scope) { return RuntimeHelper.asArray(addr, $LAYOUT(), 1, scope); }
 }
 
-
diff --git a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/fuse_fill_dir_t.java b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/fuse_fill_dir_t.java
index 8c869235..90eb4afd 100644
--- a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/fuse_fill_dir_t.java
+++ b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/fuse_fill_dir_t.java
@@ -2,32 +2,90 @@
 
 package org.cryptomator.jfuse.linux.aarch64.extr.fuse3;
 
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
+import java.lang.invoke.*;
 import java.lang.foreign.*;
+import java.nio.ByteOrder;
+import java.util.*;
+import java.util.function.*;
+import java.util.stream.*;
+
 import static java.lang.foreign.ValueLayout.*;
+import static java.lang.foreign.MemoryLayout.PathElement.*;
+
 /**
- * {@snippet :
- * int (*fuse_fill_dir_t)(void* buf,char* name,struct stat* stbuf,long off,enum fuse_fill_dir_flags flags);
+ * {@snippet lang=c :
+ * typedef int (*fuse_fill_dir_t)(void *, const char *, const struct stat {
+ *     __dev_t st_dev;
+ *     __ino64_t st_ino;
+ *     __mode_t st_mode;
+ *     __nlink_t st_nlink;
+ *     __uid_t st_uid;
+ *     __gid_t st_gid;
+ *     __dev_t st_rdev;
+ *     __dev_t __pad1;
+ *     __off64_t st_size;
+ *     __blksize_t st_blksize;
+ *     int __pad2;
+ *     __blkcnt64_t st_blocks;
+ *     struct timespec st_atim;
+ *     struct timespec st_mtim;
+ *     struct timespec st_ctim;
+ *     int __glibc_reserved[2];
+ * } *, off_t, enum fuse_fill_dir_flags {
+ *     FUSE_FILL_DIR_PLUS = (1 << 1)
+ * })
  * }
  */
-public interface fuse_fill_dir_t {
+public class fuse_fill_dir_t {
 
-    int apply(java.lang.foreign.MemorySegment buf, java.lang.foreign.MemorySegment name, java.lang.foreign.MemorySegment stbuf, long off, int flags);
-    static MemorySegment allocate(fuse_fill_dir_t fi, Arena scope) {
-        return RuntimeHelper.upcallStub(constants$10.const$1, fi, constants$10.const$0, scope);
+    fuse_fill_dir_t() {
+        // Should not be called directly
     }
-    static fuse_fill_dir_t ofAddress(MemorySegment addr, Arena arena) {
-        MemorySegment symbol = addr.reinterpret(arena, null);
-        return (java.lang.foreign.MemorySegment _buf, java.lang.foreign.MemorySegment _name, java.lang.foreign.MemorySegment _stbuf, long _off, int _flags) -> {
-            try {
-                return (int)constants$10.const$2.invokeExact(symbol, _buf, _name, _stbuf, _off, _flags);
-            } catch (Throwable ex$) {
-                throw new AssertionError("should not reach here", ex$);
-            }
-        };
+
+    /**
+     * The function pointer signature, expressed as a functional interface
+     */
+    public interface Function {
+        int apply(MemorySegment buf, MemorySegment name, MemorySegment stbuf, long off, int flags);
     }
-}
 
+    private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+        fuse_h.C_INT,
+        fuse_h.C_POINTER,
+        fuse_h.C_POINTER,
+        fuse_h.C_POINTER,
+        fuse_h.C_LONG,
+        fuse_h.C_INT
+    );
+
+    /**
+     * The descriptor of this function pointer
+     */
+    public static FunctionDescriptor descriptor() {
+        return $DESC;
+    }
+
+    private static final MethodHandle UP$MH = fuse_h.upcallHandle(fuse_fill_dir_t.Function.class, "apply", $DESC);
+
+    /**
+     * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+     * The lifetime of the returned segment is managed by {@code arena}
+     */
+    public static MemorySegment allocate(fuse_fill_dir_t.Function fi, Arena arena) {
+        return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+    }
+
+    private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+    /**
+     * Invoke the upcall stub {@code funcPtr}, with given parameters
+     */
+    public static int invoke(MemorySegment funcPtr,MemorySegment buf, MemorySegment name, MemorySegment stbuf, long off, int flags) {
+        try {
+            return (int) DOWN$MH.invokeExact(funcPtr, buf, name, stbuf, off, flags);
+        } catch (Throwable ex$) {
+            throw new AssertionError("should not reach here", ex$);
+        }
+    }
+}
 
diff --git a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/fuse_h.java b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/fuse_h.java
index 75f5107e..aabe824b 100644
--- a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/fuse_h.java
+++ b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/fuse_h.java
@@ -2,245 +2,725 @@
 
 package org.cryptomator.jfuse.linux.aarch64.extr.fuse3;
 
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
+import java.lang.invoke.*;
 import java.lang.foreign.*;
+import java.nio.ByteOrder;
+import java.util.*;
+import java.util.function.*;
+import java.util.stream.*;
+
 import static java.lang.foreign.ValueLayout.*;
-public class fuse_h  {
+import static java.lang.foreign.MemoryLayout.PathElement.*;
+
+public class fuse_h {
+
+    fuse_h() {
+        // Should not be called directly
+    }
+
+    static final Arena LIBRARY_ARENA = Arena.ofAuto();
+    static final boolean TRACE_DOWNCALLS = Boolean.getBoolean("jextract.trace.downcalls");
+
+    static void traceDowncall(String name, Object... args) {
+         String traceArgs = Arrays.stream(args)
+                       .map(Object::toString)
+                       .collect(Collectors.joining(", "));
+         System.out.printf("%s(%s)\n", name, traceArgs);
+    }
+
+    static MemorySegment findOrThrow(String symbol) {
+        return SYMBOL_LOOKUP.find(symbol)
+            .orElseThrow(() -> new UnsatisfiedLinkError("unresolved symbol: " + symbol));
+    }
+
+    static MethodHandle upcallHandle(Class<?> fi, String name, FunctionDescriptor fdesc) {
+        try {
+            return MethodHandles.lookup().findVirtual(fi, name, fdesc.toMethodType());
+        } catch (ReflectiveOperationException ex) {
+            throw new AssertionError(ex);
+        }
+    }
+
+    static MemoryLayout align(MemoryLayout layout, long align) {
+        return switch (layout) {
+            case PaddingLayout p -> p;
+            case ValueLayout v -> v.withByteAlignment(align);
+            case GroupLayout g -> {
+                MemoryLayout[] alignedMembers = g.memberLayouts().stream()
+                        .map(m -> align(m, align)).toArray(MemoryLayout[]::new);
+                yield g instanceof StructLayout ?
+                        MemoryLayout.structLayout(alignedMembers) : MemoryLayout.unionLayout(alignedMembers);
+            }
+            case SequenceLayout s -> MemoryLayout.sequenceLayout(s.elementCount(), align(s.elementLayout(), align));
+        };
+    }
+
+    static final SymbolLookup SYMBOL_LOOKUP = SymbolLookup.loaderLookup()
+            .or(Linker.nativeLinker().defaultLookup());
 
-    public static final OfByte C_CHAR = JAVA_BYTE;
-    public static final OfShort C_SHORT = JAVA_SHORT;
-    public static final OfInt C_INT = JAVA_INT;
-    public static final OfLong C_LONG = JAVA_LONG;
-    public static final OfLong C_LONG_LONG = JAVA_LONG;
-    public static final OfFloat C_FLOAT = JAVA_FLOAT;
-    public static final OfDouble C_DOUBLE = JAVA_DOUBLE;
-    public static final AddressLayout C_POINTER = RuntimeHelper.POINTER;
-    public static MethodHandle fuse_version$MH() {
-        return RuntimeHelper.requireNonNull(constants$4.const$3,"fuse_version");
+    public static final ValueLayout.OfBoolean C_BOOL = ValueLayout.JAVA_BOOLEAN;
+    public static final ValueLayout.OfByte C_CHAR = ValueLayout.JAVA_BYTE;
+    public static final ValueLayout.OfShort C_SHORT = ValueLayout.JAVA_SHORT;
+    public static final ValueLayout.OfInt C_INT = ValueLayout.JAVA_INT;
+    public static final ValueLayout.OfLong C_LONG_LONG = ValueLayout.JAVA_LONG;
+    public static final ValueLayout.OfFloat C_FLOAT = ValueLayout.JAVA_FLOAT;
+    public static final ValueLayout.OfDouble C_DOUBLE = ValueLayout.JAVA_DOUBLE;
+    public static final AddressLayout C_POINTER = ValueLayout.ADDRESS
+            .withTargetLayout(MemoryLayout.sequenceLayout(java.lang.Long.MAX_VALUE, JAVA_BYTE));
+    public static final ValueLayout.OfLong C_LONG = ValueLayout.JAVA_LONG;
+
+    private static class fuse_version {
+        public static final FunctionDescriptor DESC = FunctionDescriptor.of(
+            fuse_h.C_INT    );
+
+        public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(
+                    fuse_h.findOrThrow("fuse_version"),
+                    DESC);
     }
+
     /**
-     * {@snippet :
-     * int fuse_version();
+     * Function descriptor for:
+     * {@snippet lang=c :
+     * int fuse_version()
+     * }
+     */
+    public static FunctionDescriptor fuse_version$descriptor() {
+        return fuse_version.DESC;
+    }
+
+    /**
+     * Downcall method handle for:
+     * {@snippet lang=c :
+     * int fuse_version()
+     * }
+     */
+    public static MethodHandle fuse_version$handle() {
+        return fuse_version.HANDLE;
+    }
+    /**
+     * {@snippet lang=c :
+     * int fuse_version()
      * }
      */
     public static int fuse_version() {
-        var mh$ = fuse_version$MH();
+        var mh$ = fuse_version.HANDLE;
         try {
+            if (TRACE_DOWNCALLS) {
+                traceDowncall("fuse_version");
+            }
             return (int)mh$.invokeExact();
         } catch (Throwable ex$) {
-            throw new AssertionError("should not reach here", ex$);
+           throw new AssertionError("should not reach here", ex$);
         }
     }
-    public static MethodHandle fuse_loop_cfg_create$MH() {
-        return RuntimeHelper.requireNonNull(constants$4.const$5,"fuse_loop_cfg_create");
+
+    private static class fuse_loop_cfg_create {
+        public static final FunctionDescriptor DESC = FunctionDescriptor.of(
+            fuse_h.C_POINTER    );
+
+        public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(
+                    fuse_h.findOrThrow("fuse_loop_cfg_create"),
+                    DESC);
     }
+
     /**
-     * {@snippet :
-     * struct fuse_loop_config* fuse_loop_cfg_create();
+     * Function descriptor for:
+     * {@snippet lang=c :
+     * struct fuse_loop_config *fuse_loop_cfg_create()
+     * }
+     */
+    public static FunctionDescriptor fuse_loop_cfg_create$descriptor() {
+        return fuse_loop_cfg_create.DESC;
+    }
+
+    /**
+     * Downcall method handle for:
+     * {@snippet lang=c :
+     * struct fuse_loop_config *fuse_loop_cfg_create()
+     * }
+     */
+    public static MethodHandle fuse_loop_cfg_create$handle() {
+        return fuse_loop_cfg_create.HANDLE;
+    }
+    /**
+     * {@snippet lang=c :
+     * struct fuse_loop_config *fuse_loop_cfg_create()
      * }
      */
     public static MemorySegment fuse_loop_cfg_create() {
-        var mh$ = fuse_loop_cfg_create$MH();
+        var mh$ = fuse_loop_cfg_create.HANDLE;
         try {
-            return (java.lang.foreign.MemorySegment)mh$.invokeExact();
+            if (TRACE_DOWNCALLS) {
+                traceDowncall("fuse_loop_cfg_create");
+            }
+            return (MemorySegment)mh$.invokeExact();
         } catch (Throwable ex$) {
-            throw new AssertionError("should not reach here", ex$);
+           throw new AssertionError("should not reach here", ex$);
         }
     }
-    public static MethodHandle fuse_loop_cfg_destroy$MH() {
-        return RuntimeHelper.requireNonNull(constants$5.const$1,"fuse_loop_cfg_destroy");
+
+    private static class fuse_loop_cfg_destroy {
+        public static final FunctionDescriptor DESC = FunctionDescriptor.ofVoid(
+            fuse_h.C_POINTER
+        );
+
+        public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(
+                    fuse_h.findOrThrow("fuse_loop_cfg_destroy"),
+                    DESC);
+    }
+
+    /**
+     * Function descriptor for:
+     * {@snippet lang=c :
+     * void fuse_loop_cfg_destroy(struct fuse_loop_config *config)
+     * }
+     */
+    public static FunctionDescriptor fuse_loop_cfg_destroy$descriptor() {
+        return fuse_loop_cfg_destroy.DESC;
+    }
+
+    /**
+     * Downcall method handle for:
+     * {@snippet lang=c :
+     * void fuse_loop_cfg_destroy(struct fuse_loop_config *config)
+     * }
+     */
+    public static MethodHandle fuse_loop_cfg_destroy$handle() {
+        return fuse_loop_cfg_destroy.HANDLE;
     }
     /**
-     * {@snippet :
-     * void fuse_loop_cfg_destroy(struct fuse_loop_config* config);
+     * {@snippet lang=c :
+     * void fuse_loop_cfg_destroy(struct fuse_loop_config *config)
      * }
      */
     public static void fuse_loop_cfg_destroy(MemorySegment config) {
-        var mh$ = fuse_loop_cfg_destroy$MH();
+        var mh$ = fuse_loop_cfg_destroy.HANDLE;
         try {
+            if (TRACE_DOWNCALLS) {
+                traceDowncall("fuse_loop_cfg_destroy", config);
+            }
             mh$.invokeExact(config);
         } catch (Throwable ex$) {
-            throw new AssertionError("should not reach here", ex$);
+           throw new AssertionError("should not reach here", ex$);
         }
     }
-    public static MethodHandle fuse_loop_cfg_set_max_threads$MH() {
-        return RuntimeHelper.requireNonNull(constants$5.const$3,"fuse_loop_cfg_set_max_threads");
+
+    private static class fuse_loop_cfg_set_max_threads {
+        public static final FunctionDescriptor DESC = FunctionDescriptor.ofVoid(
+            fuse_h.C_POINTER,
+            fuse_h.C_INT
+        );
+
+        public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(
+                    fuse_h.findOrThrow("fuse_loop_cfg_set_max_threads"),
+                    DESC);
+    }
+
+    /**
+     * Function descriptor for:
+     * {@snippet lang=c :
+     * void fuse_loop_cfg_set_max_threads(struct fuse_loop_config *config, unsigned int value)
+     * }
+     */
+    public static FunctionDescriptor fuse_loop_cfg_set_max_threads$descriptor() {
+        return fuse_loop_cfg_set_max_threads.DESC;
+    }
+
+    /**
+     * Downcall method handle for:
+     * {@snippet lang=c :
+     * void fuse_loop_cfg_set_max_threads(struct fuse_loop_config *config, unsigned int value)
+     * }
+     */
+    public static MethodHandle fuse_loop_cfg_set_max_threads$handle() {
+        return fuse_loop_cfg_set_max_threads.HANDLE;
     }
     /**
-     * {@snippet :
-     * void fuse_loop_cfg_set_max_threads(struct fuse_loop_config* config, unsigned int value);
+     * {@snippet lang=c :
+     * void fuse_loop_cfg_set_max_threads(struct fuse_loop_config *config, unsigned int value)
      * }
      */
     public static void fuse_loop_cfg_set_max_threads(MemorySegment config, int value) {
-        var mh$ = fuse_loop_cfg_set_max_threads$MH();
+        var mh$ = fuse_loop_cfg_set_max_threads.HANDLE;
         try {
+            if (TRACE_DOWNCALLS) {
+                traceDowncall("fuse_loop_cfg_set_max_threads", config, value);
+            }
             mh$.invokeExact(config, value);
         } catch (Throwable ex$) {
-            throw new AssertionError("should not reach here", ex$);
+           throw new AssertionError("should not reach here", ex$);
         }
     }
-    public static MethodHandle fuse_loop_cfg_set_clone_fd$MH() {
-        return RuntimeHelper.requireNonNull(constants$5.const$4,"fuse_loop_cfg_set_clone_fd");
+
+    private static class fuse_loop_cfg_set_clone_fd {
+        public static final FunctionDescriptor DESC = FunctionDescriptor.ofVoid(
+            fuse_h.C_POINTER,
+            fuse_h.C_INT
+        );
+
+        public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(
+                    fuse_h.findOrThrow("fuse_loop_cfg_set_clone_fd"),
+                    DESC);
     }
+
     /**
-     * {@snippet :
-     * void fuse_loop_cfg_set_clone_fd(struct fuse_loop_config* config, unsigned int value);
+     * Function descriptor for:
+     * {@snippet lang=c :
+     * void fuse_loop_cfg_set_clone_fd(struct fuse_loop_config *config, unsigned int value)
+     * }
+     */
+    public static FunctionDescriptor fuse_loop_cfg_set_clone_fd$descriptor() {
+        return fuse_loop_cfg_set_clone_fd.DESC;
+    }
+
+    /**
+     * Downcall method handle for:
+     * {@snippet lang=c :
+     * void fuse_loop_cfg_set_clone_fd(struct fuse_loop_config *config, unsigned int value)
+     * }
+     */
+    public static MethodHandle fuse_loop_cfg_set_clone_fd$handle() {
+        return fuse_loop_cfg_set_clone_fd.HANDLE;
+    }
+    /**
+     * {@snippet lang=c :
+     * void fuse_loop_cfg_set_clone_fd(struct fuse_loop_config *config, unsigned int value)
      * }
      */
     public static void fuse_loop_cfg_set_clone_fd(MemorySegment config, int value) {
-        var mh$ = fuse_loop_cfg_set_clone_fd$MH();
+        var mh$ = fuse_loop_cfg_set_clone_fd.HANDLE;
         try {
+            if (TRACE_DOWNCALLS) {
+                traceDowncall("fuse_loop_cfg_set_clone_fd", config, value);
+            }
             mh$.invokeExact(config, value);
         } catch (Throwable ex$) {
-            throw new AssertionError("should not reach here", ex$);
+           throw new AssertionError("should not reach here", ex$);
         }
     }
-    public static MethodHandle fuse_lib_help$MH() {
-        return RuntimeHelper.requireNonNull(constants$36.const$1,"fuse_lib_help");
+
+    private static class fuse_lib_help {
+        public static final FunctionDescriptor DESC = FunctionDescriptor.ofVoid(
+            fuse_h.C_POINTER
+        );
+
+        public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(
+                    fuse_h.findOrThrow("fuse_lib_help"),
+                    DESC);
     }
+
     /**
-     * {@snippet :
-     * void fuse_lib_help(struct fuse_args* args);
+     * Function descriptor for:
+     * {@snippet lang=c :
+     * void fuse_lib_help(struct fuse_args *args)
+     * }
+     */
+    public static FunctionDescriptor fuse_lib_help$descriptor() {
+        return fuse_lib_help.DESC;
+    }
+
+    /**
+     * Downcall method handle for:
+     * {@snippet lang=c :
+     * void fuse_lib_help(struct fuse_args *args)
+     * }
+     */
+    public static MethodHandle fuse_lib_help$handle() {
+        return fuse_lib_help.HANDLE;
+    }
+    /**
+     * {@snippet lang=c :
+     * void fuse_lib_help(struct fuse_args *args)
      * }
      */
     public static void fuse_lib_help(MemorySegment args) {
-        var mh$ = fuse_lib_help$MH();
+        var mh$ = fuse_lib_help.HANDLE;
         try {
+            if (TRACE_DOWNCALLS) {
+                traceDowncall("fuse_lib_help", args);
+            }
             mh$.invokeExact(args);
         } catch (Throwable ex$) {
-            throw new AssertionError("should not reach here", ex$);
+           throw new AssertionError("should not reach here", ex$);
         }
     }
-    public static MethodHandle fuse_new$MH() {
-        return RuntimeHelper.requireNonNull(constants$36.const$3,"fuse_new");
+
+    private static class fuse_new {
+        public static final FunctionDescriptor DESC = FunctionDescriptor.of(
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER,
+            fuse_h.C_LONG,
+            fuse_h.C_POINTER
+        );
+
+        public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(
+                    fuse_h.findOrThrow("fuse_new"),
+                    DESC);
     }
+
     /**
-     * {@snippet :
-     * struct fuse* fuse_new(struct fuse_args* args, struct fuse_operations* op, unsigned long op_size, void* private_data);
+     * Function descriptor for:
+     * {@snippet lang=c :
+     * struct fuse *fuse_new(struct fuse_args *args, const struct fuse_operations *op, size_t op_size, void *private_data)
+     * }
+     */
+    public static FunctionDescriptor fuse_new$descriptor() {
+        return fuse_new.DESC;
+    }
+
+    /**
+     * Downcall method handle for:
+     * {@snippet lang=c :
+     * struct fuse *fuse_new(struct fuse_args *args, const struct fuse_operations *op, size_t op_size, void *private_data)
+     * }
+     */
+    public static MethodHandle fuse_new$handle() {
+        return fuse_new.HANDLE;
+    }
+    /**
+     * {@snippet lang=c :
+     * struct fuse *fuse_new(struct fuse_args *args, const struct fuse_operations *op, size_t op_size, void *private_data)
      * }
      */
     public static MemorySegment fuse_new(MemorySegment args, MemorySegment op, long op_size, MemorySegment private_data) {
-        var mh$ = fuse_new$MH();
+        var mh$ = fuse_new.HANDLE;
         try {
-            return (java.lang.foreign.MemorySegment)mh$.invokeExact(args, op, op_size, private_data);
+            if (TRACE_DOWNCALLS) {
+                traceDowncall("fuse_new", args, op, op_size, private_data);
+            }
+            return (MemorySegment)mh$.invokeExact(args, op, op_size, private_data);
         } catch (Throwable ex$) {
-            throw new AssertionError("should not reach here", ex$);
+           throw new AssertionError("should not reach here", ex$);
         }
     }
-    public static MethodHandle fuse_mount$MH() {
-        return RuntimeHelper.requireNonNull(constants$36.const$4,"fuse_mount");
+
+    private static class fuse_mount {
+        public static final FunctionDescriptor DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER
+        );
+
+        public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(
+                    fuse_h.findOrThrow("fuse_mount"),
+                    DESC);
+    }
+
+    /**
+     * Function descriptor for:
+     * {@snippet lang=c :
+     * int fuse_mount(struct fuse *f, const char *mountpoint)
+     * }
+     */
+    public static FunctionDescriptor fuse_mount$descriptor() {
+        return fuse_mount.DESC;
+    }
+
+    /**
+     * Downcall method handle for:
+     * {@snippet lang=c :
+     * int fuse_mount(struct fuse *f, const char *mountpoint)
+     * }
+     */
+    public static MethodHandle fuse_mount$handle() {
+        return fuse_mount.HANDLE;
     }
     /**
-     * {@snippet :
-     * int fuse_mount(struct fuse* f, char* mountpoint);
+     * {@snippet lang=c :
+     * int fuse_mount(struct fuse *f, const char *mountpoint)
      * }
      */
     public static int fuse_mount(MemorySegment f, MemorySegment mountpoint) {
-        var mh$ = fuse_mount$MH();
+        var mh$ = fuse_mount.HANDLE;
         try {
+            if (TRACE_DOWNCALLS) {
+                traceDowncall("fuse_mount", f, mountpoint);
+            }
             return (int)mh$.invokeExact(f, mountpoint);
         } catch (Throwable ex$) {
-            throw new AssertionError("should not reach here", ex$);
+           throw new AssertionError("should not reach here", ex$);
         }
     }
-    public static MethodHandle fuse_unmount$MH() {
-        return RuntimeHelper.requireNonNull(constants$36.const$5,"fuse_unmount");
+
+    private static class fuse_unmount {
+        public static final FunctionDescriptor DESC = FunctionDescriptor.ofVoid(
+            fuse_h.C_POINTER
+        );
+
+        public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(
+                    fuse_h.findOrThrow("fuse_unmount"),
+                    DESC);
     }
+
     /**
-     * {@snippet :
-     * void fuse_unmount(struct fuse* f);
+     * Function descriptor for:
+     * {@snippet lang=c :
+     * void fuse_unmount(struct fuse *f)
+     * }
+     */
+    public static FunctionDescriptor fuse_unmount$descriptor() {
+        return fuse_unmount.DESC;
+    }
+
+    /**
+     * Downcall method handle for:
+     * {@snippet lang=c :
+     * void fuse_unmount(struct fuse *f)
+     * }
+     */
+    public static MethodHandle fuse_unmount$handle() {
+        return fuse_unmount.HANDLE;
+    }
+    /**
+     * {@snippet lang=c :
+     * void fuse_unmount(struct fuse *f)
      * }
      */
     public static void fuse_unmount(MemorySegment f) {
-        var mh$ = fuse_unmount$MH();
+        var mh$ = fuse_unmount.HANDLE;
         try {
+            if (TRACE_DOWNCALLS) {
+                traceDowncall("fuse_unmount", f);
+            }
             mh$.invokeExact(f);
         } catch (Throwable ex$) {
-            throw new AssertionError("should not reach here", ex$);
+           throw new AssertionError("should not reach here", ex$);
         }
     }
-    public static MethodHandle fuse_destroy$MH() {
-        return RuntimeHelper.requireNonNull(constants$37.const$0,"fuse_destroy");
+
+    private static class fuse_destroy {
+        public static final FunctionDescriptor DESC = FunctionDescriptor.ofVoid(
+            fuse_h.C_POINTER
+        );
+
+        public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(
+                    fuse_h.findOrThrow("fuse_destroy"),
+                    DESC);
     }
+
     /**
-     * {@snippet :
-     * void fuse_destroy(struct fuse* f);
+     * Function descriptor for:
+     * {@snippet lang=c :
+     * void fuse_destroy(struct fuse *f)
+     * }
+     */
+    public static FunctionDescriptor fuse_destroy$descriptor() {
+        return fuse_destroy.DESC;
+    }
+
+    /**
+     * Downcall method handle for:
+     * {@snippet lang=c :
+     * void fuse_destroy(struct fuse *f)
+     * }
+     */
+    public static MethodHandle fuse_destroy$handle() {
+        return fuse_destroy.HANDLE;
+    }
+    /**
+     * {@snippet lang=c :
+     * void fuse_destroy(struct fuse *f)
      * }
      */
     public static void fuse_destroy(MemorySegment f) {
-        var mh$ = fuse_destroy$MH();
+        var mh$ = fuse_destroy.HANDLE;
         try {
+            if (TRACE_DOWNCALLS) {
+                traceDowncall("fuse_destroy", f);
+            }
             mh$.invokeExact(f);
         } catch (Throwable ex$) {
-            throw new AssertionError("should not reach here", ex$);
+           throw new AssertionError("should not reach here", ex$);
         }
     }
-    public static MethodHandle fuse_loop$MH() {
-        return RuntimeHelper.requireNonNull(constants$37.const$1,"fuse_loop");
+
+    private static class fuse_loop {
+        public static final FunctionDescriptor DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER
+        );
+
+        public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(
+                    fuse_h.findOrThrow("fuse_loop"),
+                    DESC);
     }
+
     /**
-     * {@snippet :
-     * int fuse_loop(struct fuse* f);
+     * Function descriptor for:
+     * {@snippet lang=c :
+     * int fuse_loop(struct fuse *f)
+     * }
+     */
+    public static FunctionDescriptor fuse_loop$descriptor() {
+        return fuse_loop.DESC;
+    }
+
+    /**
+     * Downcall method handle for:
+     * {@snippet lang=c :
+     * int fuse_loop(struct fuse *f)
+     * }
+     */
+    public static MethodHandle fuse_loop$handle() {
+        return fuse_loop.HANDLE;
+    }
+    /**
+     * {@snippet lang=c :
+     * int fuse_loop(struct fuse *f)
      * }
      */
     public static int fuse_loop(MemorySegment f) {
-        var mh$ = fuse_loop$MH();
+        var mh$ = fuse_loop.HANDLE;
         try {
+            if (TRACE_DOWNCALLS) {
+                traceDowncall("fuse_loop", f);
+            }
             return (int)mh$.invokeExact(f);
         } catch (Throwable ex$) {
-            throw new AssertionError("should not reach here", ex$);
+           throw new AssertionError("should not reach here", ex$);
         }
     }
-    public static MethodHandle fuse_exit$MH() {
-        return RuntimeHelper.requireNonNull(constants$37.const$2,"fuse_exit");
+
+    private static class fuse_exit {
+        public static final FunctionDescriptor DESC = FunctionDescriptor.ofVoid(
+            fuse_h.C_POINTER
+        );
+
+        public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(
+                    fuse_h.findOrThrow("fuse_exit"),
+                    DESC);
     }
+
     /**
-     * {@snippet :
-     * void fuse_exit(struct fuse* f);
+     * Function descriptor for:
+     * {@snippet lang=c :
+     * void fuse_exit(struct fuse *f)
+     * }
+     */
+    public static FunctionDescriptor fuse_exit$descriptor() {
+        return fuse_exit.DESC;
+    }
+
+    /**
+     * Downcall method handle for:
+     * {@snippet lang=c :
+     * void fuse_exit(struct fuse *f)
+     * }
+     */
+    public static MethodHandle fuse_exit$handle() {
+        return fuse_exit.HANDLE;
+    }
+    /**
+     * {@snippet lang=c :
+     * void fuse_exit(struct fuse *f)
      * }
      */
     public static void fuse_exit(MemorySegment f) {
-        var mh$ = fuse_exit$MH();
+        var mh$ = fuse_exit.HANDLE;
         try {
+            if (TRACE_DOWNCALLS) {
+                traceDowncall("fuse_exit", f);
+            }
             mh$.invokeExact(f);
         } catch (Throwable ex$) {
-            throw new AssertionError("should not reach here", ex$);
+           throw new AssertionError("should not reach here", ex$);
         }
     }
-    public static MethodHandle fuse_loop_mt$MH() {
-        return RuntimeHelper.requireNonNull(constants$37.const$3,"fuse_loop_mt");
+
+    private static class fuse_loop_mt {
+        public static final FunctionDescriptor DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER
+        );
+
+        public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(
+                    fuse_h.findOrThrow("fuse_loop_mt"),
+                    DESC);
+    }
+
+    /**
+     * Function descriptor for:
+     * {@snippet lang=c :
+     * int fuse_loop_mt(struct fuse *f, struct fuse_loop_config *config)
+     * }
+     */
+    public static FunctionDescriptor fuse_loop_mt$descriptor() {
+        return fuse_loop_mt.DESC;
+    }
+
+    /**
+     * Downcall method handle for:
+     * {@snippet lang=c :
+     * int fuse_loop_mt(struct fuse *f, struct fuse_loop_config *config)
+     * }
+     */
+    public static MethodHandle fuse_loop_mt$handle() {
+        return fuse_loop_mt.HANDLE;
     }
     /**
-     * {@snippet :
-     * int fuse_loop_mt(struct fuse* f, struct fuse_loop_config* config);
+     * {@snippet lang=c :
+     * int fuse_loop_mt(struct fuse *f, struct fuse_loop_config *config)
      * }
      */
     public static int fuse_loop_mt(MemorySegment f, MemorySegment config) {
-        var mh$ = fuse_loop_mt$MH();
+        var mh$ = fuse_loop_mt.HANDLE;
         try {
+            if (TRACE_DOWNCALLS) {
+                traceDowncall("fuse_loop_mt", f, config);
+            }
             return (int)mh$.invokeExact(f, config);
         } catch (Throwable ex$) {
-            throw new AssertionError("should not reach here", ex$);
+           throw new AssertionError("should not reach here", ex$);
         }
     }
-    public static MethodHandle fuse_get_session$MH() {
-        return RuntimeHelper.requireNonNull(constants$37.const$5,"fuse_get_session");
+
+    private static class fuse_get_session {
+        public static final FunctionDescriptor DESC = FunctionDescriptor.of(
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER
+        );
+
+        public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(
+                    fuse_h.findOrThrow("fuse_get_session"),
+                    DESC);
     }
+
+    /**
+     * Function descriptor for:
+     * {@snippet lang=c :
+     * struct fuse_session *fuse_get_session(struct fuse *f)
+     * }
+     */
+    public static FunctionDescriptor fuse_get_session$descriptor() {
+        return fuse_get_session.DESC;
+    }
+
     /**
-     * {@snippet :
-     * struct fuse_session* fuse_get_session(struct fuse* f);
+     * Downcall method handle for:
+     * {@snippet lang=c :
+     * struct fuse_session *fuse_get_session(struct fuse *f)
+     * }
+     */
+    public static MethodHandle fuse_get_session$handle() {
+        return fuse_get_session.HANDLE;
+    }
+    /**
+     * {@snippet lang=c :
+     * struct fuse_session *fuse_get_session(struct fuse *f)
      * }
      */
     public static MemorySegment fuse_get_session(MemorySegment f) {
-        var mh$ = fuse_get_session$MH();
+        var mh$ = fuse_get_session.HANDLE;
         try {
-            return (java.lang.foreign.MemorySegment)mh$.invokeExact(f);
+            if (TRACE_DOWNCALLS) {
+                traceDowncall("fuse_get_session", f);
+            }
+            return (MemorySegment)mh$.invokeExact(f);
         } catch (Throwable ex$) {
-            throw new AssertionError("should not reach here", ex$);
+           throw new AssertionError("should not reach here", ex$);
         }
     }
 }
 
-
diff --git a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/fuse_loop_config_v1.java b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/fuse_loop_config_v1.java
index cb426eca..81a41d45 100644
--- a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/fuse_loop_config_v1.java
+++ b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/fuse_loop_config_v1.java
@@ -2,84 +2,172 @@
 
 package org.cryptomator.jfuse.linux.aarch64.extr.fuse3;
 
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
+import java.lang.invoke.*;
 import java.lang.foreign.*;
+import java.nio.ByteOrder;
+import java.util.*;
+import java.util.function.*;
+import java.util.stream.*;
+
 import static java.lang.foreign.ValueLayout.*;
+import static java.lang.foreign.MemoryLayout.PathElement.*;
+
 /**
- * {@snippet :
+ * {@snippet lang=c :
  * struct fuse_loop_config_v1 {
  *     int clone_fd;
  *     unsigned int max_idle_threads;
- * };
+ * }
  * }
  */
 public class fuse_loop_config_v1 {
 
-    public static MemoryLayout $LAYOUT() {
-        return constants$2.const$0;
+    fuse_loop_config_v1() {
+        // Should not be called directly
     }
-    public static VarHandle clone_fd$VH() {
-        return constants$2.const$1;
+
+    private static final GroupLayout $LAYOUT = MemoryLayout.structLayout(
+        fuse_h.C_INT.withName("clone_fd"),
+        fuse_h.C_INT.withName("max_idle_threads")
+    ).withName("fuse_loop_config_v1");
+
+    /**
+     * The layout of this struct
+     */
+    public static final GroupLayout layout() {
+        return $LAYOUT;
     }
+
+    private static final OfInt clone_fd$LAYOUT = (OfInt)$LAYOUT.select(groupElement("clone_fd"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int clone_fd
+     * }
+     */
+    public static final OfInt clone_fd$layout() {
+        return clone_fd$LAYOUT;
+    }
+
+    private static final long clone_fd$OFFSET = 0;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int clone_fd
+     * }
+     */
+    public static final long clone_fd$offset() {
+        return clone_fd$OFFSET;
+    }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int clone_fd;
+     * {@snippet lang=c :
+     * int clone_fd
      * }
      */
-    public static int clone_fd$get(MemorySegment seg) {
-        return (int)constants$2.const$1.get(seg);
+    public static int clone_fd(MemorySegment struct) {
+        return struct.get(clone_fd$LAYOUT, clone_fd$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int clone_fd;
+     * {@snippet lang=c :
+     * int clone_fd
      * }
      */
-    public static void clone_fd$set(MemorySegment seg, int x) {
-        constants$2.const$1.set(seg, x);
-    }
-    public static int clone_fd$get(MemorySegment seg, long index) {
-        return (int)constants$2.const$1.get(seg.asSlice(index*sizeof()));
+    public static void clone_fd(MemorySegment struct, int fieldValue) {
+        struct.set(clone_fd$LAYOUT, clone_fd$OFFSET, fieldValue);
     }
-    public static void clone_fd$set(MemorySegment seg, long index, int x) {
-        constants$2.const$1.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt max_idle_threads$LAYOUT = (OfInt)$LAYOUT.select(groupElement("max_idle_threads"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * unsigned int max_idle_threads
+     * }
+     */
+    public static final OfInt max_idle_threads$layout() {
+        return max_idle_threads$LAYOUT;
     }
-    public static VarHandle max_idle_threads$VH() {
-        return constants$2.const$2;
+
+    private static final long max_idle_threads$OFFSET = 4;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * unsigned int max_idle_threads
+     * }
+     */
+    public static final long max_idle_threads$offset() {
+        return max_idle_threads$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned int max_idle_threads;
+     * {@snippet lang=c :
+     * unsigned int max_idle_threads
      * }
      */
-    public static int max_idle_threads$get(MemorySegment seg) {
-        return (int)constants$2.const$2.get(seg);
+    public static int max_idle_threads(MemorySegment struct) {
+        return struct.get(max_idle_threads$LAYOUT, max_idle_threads$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned int max_idle_threads;
+     * {@snippet lang=c :
+     * unsigned int max_idle_threads
      * }
      */
-    public static void max_idle_threads$set(MemorySegment seg, int x) {
-        constants$2.const$2.set(seg, x);
+    public static void max_idle_threads(MemorySegment struct, int fieldValue) {
+        struct.set(max_idle_threads$LAYOUT, max_idle_threads$OFFSET, fieldValue);
+    }
+
+    /**
+     * Obtains a slice of {@code arrayParam} which selects the array element at {@code index}.
+     * The returned segment has address {@code arrayParam.address() + index * layout().byteSize()}
+     */
+    public static MemorySegment asSlice(MemorySegment array, long index) {
+        return array.asSlice(layout().byteSize() * index);
+    }
+
+    /**
+     * The size (in bytes) of this struct
+     */
+    public static long sizeof() { return layout().byteSize(); }
+
+    /**
+     * Allocate a segment of size {@code layout().byteSize()} using {@code allocator}
+     */
+    public static MemorySegment allocate(SegmentAllocator allocator) {
+        return allocator.allocate(layout());
     }
-    public static int max_idle_threads$get(MemorySegment seg, long index) {
-        return (int)constants$2.const$2.get(seg.asSlice(index*sizeof()));
+
+    /**
+     * Allocate an array of size {@code elementCount} using {@code allocator}.
+     * The returned segment has size {@code elementCount * layout().byteSize()}.
+     */
+    public static MemorySegment allocateArray(long elementCount, SegmentAllocator allocator) {
+        return allocator.allocate(MemoryLayout.sequenceLayout(elementCount, layout()));
     }
-    public static void max_idle_threads$set(MemorySegment seg, long index, int x) {
-        constants$2.const$2.set(seg.asSlice(index*sizeof()), x);
+
+    /**
+     * Reinterprets {@code addr} using target {@code arena} and {@code cleanupAction) (if any).
+     * The returned segment has size {@code layout().byteSize()}
+     */
+    public static MemorySegment reinterpret(MemorySegment addr, Arena arena, Consumer<MemorySegment> cleanup) {
+        return reinterpret(addr, 1, arena, cleanup);
     }
-    public static long sizeof() { return $LAYOUT().byteSize(); }
-    public static MemorySegment allocate(SegmentAllocator allocator) { return allocator.allocate($LAYOUT()); }
-    public static MemorySegment allocateArray(long len, SegmentAllocator allocator) {
-        return allocator.allocate(MemoryLayout.sequenceLayout(len, $LAYOUT()));
+
+    /**
+     * Reinterprets {@code addr} using target {@code arena} and {@code cleanupAction) (if any).
+     * The returned segment has size {@code elementCount * layout().byteSize()}
+     */
+    public static MemorySegment reinterpret(MemorySegment addr, long elementCount, Arena arena, Consumer<MemorySegment> cleanup) {
+        return addr.reinterpret(layout().byteSize() * elementCount, arena, cleanup);
     }
-    public static MemorySegment ofAddress(MemorySegment addr, Arena scope) { return RuntimeHelper.asArray(addr, $LAYOUT(), 1, scope); }
 }
 
-
diff --git a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/fuse_operations.java b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/fuse_operations.java
index 389b6326..558b3ad2 100644
--- a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/fuse_operations.java
+++ b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/fuse_operations.java
@@ -2,2296 +2,4372 @@
 
 package org.cryptomator.jfuse.linux.aarch64.extr.fuse3;
 
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
+import java.lang.invoke.*;
 import java.lang.foreign.*;
+import java.nio.ByteOrder;
+import java.util.*;
+import java.util.function.*;
+import java.util.stream.*;
+
 import static java.lang.foreign.ValueLayout.*;
+import static java.lang.foreign.MemoryLayout.PathElement.*;
+
 /**
- * {@snippet :
+ * {@snippet lang=c :
  * struct fuse_operations {
- *     int (*getattr)(char*,struct stat*,struct fuse_file_info*);
- *     int (*readlink)(char*,char*,unsigned long);
- *     int (*mknod)(char*,unsigned int,unsigned long);
- *     int (*mkdir)(char*,unsigned int);
- *     int (*unlink)(char*);
- *     int (*rmdir)(char*);
- *     int (*symlink)(char*,char*);
- *     int (*rename)(char*,char*,unsigned int);
- *     int (*link)(char*,char*);
- *     int (*chmod)(char*,unsigned int,struct fuse_file_info*);
- *     int (*chown)(char*,unsigned int,unsigned int,struct fuse_file_info*);
- *     int (*truncate)(char*,long,struct fuse_file_info*);
- *     int (*open)(char*,struct fuse_file_info*);
- *     int (*read)(char*,char*,unsigned long,long,struct fuse_file_info*);
- *     int (*write)(char*,char*,unsigned long,long,struct fuse_file_info*);
- *     int (*statfs)(char*,struct statvfs*);
- *     int (*flush)(char*,struct fuse_file_info*);
- *     int (*release)(char*,struct fuse_file_info*);
- *     int (*fsync)(char*,int,struct fuse_file_info*);
- *     int (*setxattr)(char*,char*,char*,unsigned long,int);
- *     int (*getxattr)(char*,char*,char*,unsigned long);
- *     int (*listxattr)(char*,char*,unsigned long);
- *     int (*removexattr)(char*,char*);
- *     int (*opendir)(char*,struct fuse_file_info*);
- *     int (*readdir)(char*,void*,int (*)(void*,char*,struct stat*,long,enum fuse_fill_dir_flags),long,struct fuse_file_info*,enum fuse_readdir_flags);
- *     int (*releasedir)(char*,struct fuse_file_info*);
- *     int (*fsyncdir)(char*,int,struct fuse_file_info*);
- *     void* (*init)(struct fuse_conn_info*,struct fuse_config*);
- *     void (*destroy)(void*);
- *     int (*access)(char*,int);
- *     int (*create)(char*,unsigned int,struct fuse_file_info*);
- *     int (*lock)(char*,struct fuse_file_info*,int,struct flock*);
- *     int (*utimens)(char*,struct timespec*,struct fuse_file_info*);
- *     int (*bmap)(char*,unsigned long,unsigned long*);
- *     int (*ioctl)(char*,unsigned int,void*,struct fuse_file_info*,unsigned int,void*);
- *     int (*poll)(char*,struct fuse_file_info*,struct fuse_pollhandle*,unsigned int*);
- *     int (*write_buf)(char*,struct fuse_bufvec*,long,struct fuse_file_info*);
- *     int (*read_buf)(char*,struct fuse_bufvec**,unsigned long,long,struct fuse_file_info*);
- *     int (*flock)(char*,struct fuse_file_info*,int);
- *     int (*fallocate)(char*,int,long,long,struct fuse_file_info*);
- *     long (*copy_file_range)(char*,struct fuse_file_info*,long,char*,struct fuse_file_info*,long,unsigned long,int);
- *     long (*lseek)(char*,long,int,struct fuse_file_info*);
- * };
+ *     int (*getattr)(const char *, struct stat *, struct fuse_file_info *);
+ *     int (*readlink)(const char *, char *, size_t);
+ *     int (*mknod)(const char *, mode_t, dev_t);
+ *     int (*mkdir)(const char *, mode_t);
+ *     int (*unlink)(const char *);
+ *     int (*rmdir)(const char *);
+ *     int (*symlink)(const char *, const char *);
+ *     int (*rename)(const char *, const char *, unsigned int);
+ *     int (*link)(const char *, const char *);
+ *     int (*chmod)(const char *, mode_t, struct fuse_file_info *);
+ *     int (*chown)(const char *, uid_t, gid_t, struct fuse_file_info *);
+ *     int (*truncate)(const char *, off_t, struct fuse_file_info *);
+ *     int (*open)(const char *, struct fuse_file_info *);
+ *     int (*read)(const char *, char *, size_t, off_t, struct fuse_file_info *);
+ *     int (*write)(const char *, const char *, size_t, off_t, struct fuse_file_info *);
+ *     int (*statfs)(const char *, struct statvfs *);
+ *     int (*flush)(const char *, struct fuse_file_info *);
+ *     int (*release)(const char *, struct fuse_file_info *);
+ *     int (*fsync)(const char *, int, struct fuse_file_info *);
+ *     int (*setxattr)(const char *, const char *, const char *, size_t, int);
+ *     int (*getxattr)(const char *, const char *, char *, size_t);
+ *     int (*listxattr)(const char *, char *, size_t);
+ *     int (*removexattr)(const char *, const char *);
+ *     int (*opendir)(const char *, struct fuse_file_info *);
+ *     int (*readdir)(const char *, void *, fuse_fill_dir_t, off_t, struct fuse_file_info *, enum fuse_readdir_flags);
+ *     int (*releasedir)(const char *, struct fuse_file_info *);
+ *     int (*fsyncdir)(const char *, int, struct fuse_file_info *);
+ *     void *(*init)(struct fuse_conn_info *, struct fuse_config *);
+ *     void (*destroy)(void *);
+ *     int (*access)(const char *, int);
+ *     int (*create)(const char *, mode_t, struct fuse_file_info *);
+ *     int (*lock)(const char *, struct fuse_file_info *, int, struct flock *);
+ *     int (*utimens)(const char *, const struct timespec *, struct fuse_file_info *);
+ *     int (*bmap)(const char *, size_t, uint64_t *);
+ *     int (*ioctl)(const char *, unsigned int, void *, struct fuse_file_info *, unsigned int, void *);
+ *     int (*poll)(const char *, struct fuse_file_info *, struct fuse_pollhandle *, unsigned int *);
+ *     int (*write_buf)(const char *, struct fuse_bufvec *, off_t, struct fuse_file_info *);
+ *     int (*read_buf)(const char *, struct fuse_bufvec **, size_t, off_t, struct fuse_file_info *);
+ *     int (*flock)(const char *, struct fuse_file_info *, int);
+ *     int (*fallocate)(const char *, int, off_t, off_t, struct fuse_file_info *);
+ *     ssize_t (*copy_file_range)(const char *, struct fuse_file_info *, off_t, const char *, struct fuse_file_info *, off_t, size_t, int);
+ *     off_t (*lseek)(const char *, off_t, int, struct fuse_file_info *);
+ * }
  * }
  */
 public class fuse_operations {
 
-    public static MemoryLayout $LAYOUT() {
-        return constants$14.const$5;
+    fuse_operations() {
+        // Should not be called directly
     }
+
+    private static final GroupLayout $LAYOUT = MemoryLayout.structLayout(
+        fuse_h.C_POINTER.withName("getattr"),
+        fuse_h.C_POINTER.withName("readlink"),
+        fuse_h.C_POINTER.withName("mknod"),
+        fuse_h.C_POINTER.withName("mkdir"),
+        fuse_h.C_POINTER.withName("unlink"),
+        fuse_h.C_POINTER.withName("rmdir"),
+        fuse_h.C_POINTER.withName("symlink"),
+        fuse_h.C_POINTER.withName("rename"),
+        fuse_h.C_POINTER.withName("link"),
+        fuse_h.C_POINTER.withName("chmod"),
+        fuse_h.C_POINTER.withName("chown"),
+        fuse_h.C_POINTER.withName("truncate"),
+        fuse_h.C_POINTER.withName("open"),
+        fuse_h.C_POINTER.withName("read"),
+        fuse_h.C_POINTER.withName("write"),
+        fuse_h.C_POINTER.withName("statfs"),
+        fuse_h.C_POINTER.withName("flush"),
+        fuse_h.C_POINTER.withName("release"),
+        fuse_h.C_POINTER.withName("fsync"),
+        fuse_h.C_POINTER.withName("setxattr"),
+        fuse_h.C_POINTER.withName("getxattr"),
+        fuse_h.C_POINTER.withName("listxattr"),
+        fuse_h.C_POINTER.withName("removexattr"),
+        fuse_h.C_POINTER.withName("opendir"),
+        fuse_h.C_POINTER.withName("readdir"),
+        fuse_h.C_POINTER.withName("releasedir"),
+        fuse_h.C_POINTER.withName("fsyncdir"),
+        fuse_h.C_POINTER.withName("init"),
+        fuse_h.C_POINTER.withName("destroy"),
+        fuse_h.C_POINTER.withName("access"),
+        fuse_h.C_POINTER.withName("create"),
+        fuse_h.C_POINTER.withName("lock"),
+        fuse_h.C_POINTER.withName("utimens"),
+        fuse_h.C_POINTER.withName("bmap"),
+        fuse_h.C_POINTER.withName("ioctl"),
+        fuse_h.C_POINTER.withName("poll"),
+        fuse_h.C_POINTER.withName("write_buf"),
+        fuse_h.C_POINTER.withName("read_buf"),
+        fuse_h.C_POINTER.withName("flock"),
+        fuse_h.C_POINTER.withName("fallocate"),
+        fuse_h.C_POINTER.withName("copy_file_range"),
+        fuse_h.C_POINTER.withName("lseek")
+    ).withName("fuse_operations");
+
     /**
-     * {@snippet :
- * int (*getattr)(char*,struct stat*,struct fuse_file_info*);
-     * }
+     * The layout of this struct
      */
-    public interface getattr {
-
-        int apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1, java.lang.foreign.MemorySegment _x2);
-        static MemorySegment allocate(getattr fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$15.const$1, fi, constants$15.const$0, scope);
-        }
-        static getattr ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1, java.lang.foreign.MemorySegment __x2) -> {
-                try {
-                    return (int)constants$15.const$2.invokeExact(symbol, __x0, __x1, __x2);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
-        }
+    public static final GroupLayout layout() {
+        return $LAYOUT;
     }
 
-    public static VarHandle getattr$VH() {
-        return constants$15.const$3;
-    }
     /**
-     * Getter for field:
-     * {@snippet :
-     * int (*getattr)(char*,struct stat*,struct fuse_file_info*);
+     * {@snippet lang=c :
+     * int (*getattr)(const char *, struct stat *, struct fuse_file_info *)
      * }
      */
-    public static MemorySegment getattr$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$15.const$3.get(seg);
+    public static class getattr {
+
+        getattr() {
+            // Should not be called directly
+        }
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, MemorySegment _x1, MemorySegment _x2);
+        }
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(getattr.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(getattr.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1, MemorySegment _x2) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
     }
+
+    private static final AddressLayout getattr$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("getattr"));
+
     /**
-     * Setter for field:
-     * {@snippet :
-     * int (*getattr)(char*,struct stat*,struct fuse_file_info*);
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*getattr)(const char *, struct stat *, struct fuse_file_info *)
      * }
      */
-    public static void getattr$set(MemorySegment seg, MemorySegment x) {
-        constants$15.const$3.set(seg, x);
-    }
-    public static MemorySegment getattr$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$15.const$3.get(seg.asSlice(index*sizeof()));
-    }
-    public static void getattr$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$15.const$3.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static getattr getattr(MemorySegment segment, Arena scope) {
-        return getattr.ofAddress(getattr$get(segment), scope);
+    public static final AddressLayout getattr$layout() {
+        return getattr$LAYOUT;
     }
+
+    private static final long getattr$OFFSET = 0;
+
     /**
-     * {@snippet :
- * int (*readlink)(char*,char*,unsigned long);
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*getattr)(const char *, struct stat *, struct fuse_file_info *)
      * }
      */
-    public interface readlink {
-
-        int apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1, long _x2);
-        static MemorySegment allocate(readlink fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$15.const$5, fi, constants$15.const$4, scope);
-        }
-        static readlink ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1, long __x2) -> {
-                try {
-                    return (int)constants$16.const$0.invokeExact(symbol, __x0, __x1, __x2);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
-        }
+    public static final long getattr$offset() {
+        return getattr$OFFSET;
     }
 
-    public static VarHandle readlink$VH() {
-        return constants$16.const$1;
-    }
     /**
      * Getter for field:
-     * {@snippet :
-     * int (*readlink)(char*,char*,unsigned long);
+     * {@snippet lang=c :
+     * int (*getattr)(const char *, struct stat *, struct fuse_file_info *)
      * }
      */
-    public static MemorySegment readlink$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$16.const$1.get(seg);
+    public static MemorySegment getattr(MemorySegment struct) {
+        return struct.get(getattr$LAYOUT, getattr$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int (*readlink)(char*,char*,unsigned long);
+     * {@snippet lang=c :
+     * int (*getattr)(const char *, struct stat *, struct fuse_file_info *)
      * }
      */
-    public static void readlink$set(MemorySegment seg, MemorySegment x) {
-        constants$16.const$1.set(seg, x);
-    }
-    public static MemorySegment readlink$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$16.const$1.get(seg.asSlice(index*sizeof()));
-    }
-    public static void readlink$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$16.const$1.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static readlink readlink(MemorySegment segment, Arena scope) {
-        return readlink.ofAddress(readlink$get(segment), scope);
+    public static void getattr(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(getattr$LAYOUT, getattr$OFFSET, fieldValue);
     }
+
     /**
-     * {@snippet :
- * int (*mknod)(char*,unsigned int,unsigned long);
+     * {@snippet lang=c :
+     * int (*readlink)(const char *, char *, size_t)
      * }
      */
-    public interface mknod {
+    public static class readlink {
 
-        int apply(java.lang.foreign.MemorySegment _x0, int _x1, long _x2);
-        static MemorySegment allocate(mknod fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$16.const$3, fi, constants$16.const$2, scope);
+        readlink() {
+            // Should not be called directly
         }
-        static mknod ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, int __x1, long __x2) -> {
-                try {
-                    return (int)constants$16.const$4.invokeExact(symbol, __x0, __x1, __x2);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, MemorySegment _x1, long _x2);
         }
-    }
 
-    public static VarHandle mknod$VH() {
-        return constants$16.const$5;
-    }
-    /**
-     * Getter for field:
-     * {@snippet :
-     * int (*mknod)(char*,unsigned int,unsigned long);
-     * }
-     */
-    public static MemorySegment mknod$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$16.const$5.get(seg);
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER,
+            fuse_h.C_LONG
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(readlink.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(readlink.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1, long _x2) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
     }
+
+    private static final AddressLayout readlink$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("readlink"));
+
     /**
-     * Setter for field:
-     * {@snippet :
-     * int (*mknod)(char*,unsigned int,unsigned long);
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*readlink)(const char *, char *, size_t)
      * }
      */
-    public static void mknod$set(MemorySegment seg, MemorySegment x) {
-        constants$16.const$5.set(seg, x);
-    }
-    public static MemorySegment mknod$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$16.const$5.get(seg.asSlice(index*sizeof()));
-    }
-    public static void mknod$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$16.const$5.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static mknod mknod(MemorySegment segment, Arena scope) {
-        return mknod.ofAddress(mknod$get(segment), scope);
+    public static final AddressLayout readlink$layout() {
+        return readlink$LAYOUT;
     }
+
+    private static final long readlink$OFFSET = 8;
+
     /**
-     * {@snippet :
- * int (*mkdir)(char*,unsigned int);
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*readlink)(const char *, char *, size_t)
      * }
      */
-    public interface mkdir {
-
-        int apply(java.lang.foreign.MemorySegment _x0, int _x1);
-        static MemorySegment allocate(mkdir fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$17.const$1, fi, constants$17.const$0, scope);
-        }
-        static mkdir ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, int __x1) -> {
-                try {
-                    return (int)constants$17.const$2.invokeExact(symbol, __x0, __x1);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
-        }
+    public static final long readlink$offset() {
+        return readlink$OFFSET;
     }
 
-    public static VarHandle mkdir$VH() {
-        return constants$17.const$3;
-    }
     /**
      * Getter for field:
-     * {@snippet :
-     * int (*mkdir)(char*,unsigned int);
+     * {@snippet lang=c :
+     * int (*readlink)(const char *, char *, size_t)
      * }
      */
-    public static MemorySegment mkdir$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$17.const$3.get(seg);
+    public static MemorySegment readlink(MemorySegment struct) {
+        return struct.get(readlink$LAYOUT, readlink$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int (*mkdir)(char*,unsigned int);
+     * {@snippet lang=c :
+     * int (*readlink)(const char *, char *, size_t)
      * }
      */
-    public static void mkdir$set(MemorySegment seg, MemorySegment x) {
-        constants$17.const$3.set(seg, x);
-    }
-    public static MemorySegment mkdir$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$17.const$3.get(seg.asSlice(index*sizeof()));
-    }
-    public static void mkdir$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$17.const$3.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static mkdir mkdir(MemorySegment segment, Arena scope) {
-        return mkdir.ofAddress(mkdir$get(segment), scope);
+    public static void readlink(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(readlink$LAYOUT, readlink$OFFSET, fieldValue);
     }
+
     /**
-     * {@snippet :
- * int (*unlink)(char*);
+     * {@snippet lang=c :
+     * int (*mknod)(const char *, mode_t, dev_t)
      * }
      */
-    public interface unlink {
+    public static class mknod {
 
-        int apply(java.lang.foreign.MemorySegment _x0);
-        static MemorySegment allocate(unlink fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$17.const$5, fi, constants$17.const$4, scope);
+        mknod() {
+            // Should not be called directly
         }
-        static unlink ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0) -> {
-                try {
-                    return (int)constants$18.const$0.invokeExact(symbol, __x0);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, int _x1, long _x2);
         }
-    }
 
-    public static VarHandle unlink$VH() {
-        return constants$18.const$1;
-    }
-    /**
-     * Getter for field:
-     * {@snippet :
-     * int (*unlink)(char*);
-     * }
-     */
-    public static MemorySegment unlink$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$18.const$1.get(seg);
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_INT,
+            fuse_h.C_LONG
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(mknod.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(mknod.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, int _x1, long _x2) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
     }
+
+    private static final AddressLayout mknod$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("mknod"));
+
     /**
-     * Setter for field:
-     * {@snippet :
-     * int (*unlink)(char*);
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*mknod)(const char *, mode_t, dev_t)
      * }
      */
-    public static void unlink$set(MemorySegment seg, MemorySegment x) {
-        constants$18.const$1.set(seg, x);
-    }
-    public static MemorySegment unlink$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$18.const$1.get(seg.asSlice(index*sizeof()));
-    }
-    public static void unlink$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$18.const$1.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static unlink unlink(MemorySegment segment, Arena scope) {
-        return unlink.ofAddress(unlink$get(segment), scope);
+    public static final AddressLayout mknod$layout() {
+        return mknod$LAYOUT;
     }
+
+    private static final long mknod$OFFSET = 16;
+
     /**
-     * {@snippet :
- * int (*rmdir)(char*);
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*mknod)(const char *, mode_t, dev_t)
      * }
      */
-    public interface rmdir {
-
-        int apply(java.lang.foreign.MemorySegment _x0);
-        static MemorySegment allocate(rmdir fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$18.const$2, fi, constants$17.const$4, scope);
-        }
-        static rmdir ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0) -> {
-                try {
-                    return (int)constants$18.const$0.invokeExact(symbol, __x0);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
-        }
+    public static final long mknod$offset() {
+        return mknod$OFFSET;
     }
 
-    public static VarHandle rmdir$VH() {
-        return constants$18.const$3;
-    }
     /**
      * Getter for field:
-     * {@snippet :
-     * int (*rmdir)(char*);
+     * {@snippet lang=c :
+     * int (*mknod)(const char *, mode_t, dev_t)
      * }
      */
-    public static MemorySegment rmdir$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$18.const$3.get(seg);
+    public static MemorySegment mknod(MemorySegment struct) {
+        return struct.get(mknod$LAYOUT, mknod$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int (*rmdir)(char*);
+     * {@snippet lang=c :
+     * int (*mknod)(const char *, mode_t, dev_t)
      * }
      */
-    public static void rmdir$set(MemorySegment seg, MemorySegment x) {
-        constants$18.const$3.set(seg, x);
-    }
-    public static MemorySegment rmdir$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$18.const$3.get(seg.asSlice(index*sizeof()));
-    }
-    public static void rmdir$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$18.const$3.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static rmdir rmdir(MemorySegment segment, Arena scope) {
-        return rmdir.ofAddress(rmdir$get(segment), scope);
+    public static void mknod(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(mknod$LAYOUT, mknod$OFFSET, fieldValue);
     }
+
     /**
-     * {@snippet :
- * int (*symlink)(char*,char*);
+     * {@snippet lang=c :
+     * int (*mkdir)(const char *, mode_t)
      * }
      */
-    public interface symlink {
+    public static class mkdir {
 
-        int apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1);
-        static MemorySegment allocate(symlink fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$18.const$5, fi, constants$18.const$4, scope);
+        mkdir() {
+            // Should not be called directly
         }
-        static symlink ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1) -> {
-                try {
-                    return (int)constants$19.const$0.invokeExact(symbol, __x0, __x1);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, int _x1);
         }
-    }
 
-    public static VarHandle symlink$VH() {
-        return constants$19.const$1;
-    }
-    /**
-     * Getter for field:
-     * {@snippet :
-     * int (*symlink)(char*,char*);
-     * }
-     */
-    public static MemorySegment symlink$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$19.const$1.get(seg);
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_INT
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(mkdir.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(mkdir.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, int _x1) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
     }
+
+    private static final AddressLayout mkdir$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("mkdir"));
+
     /**
-     * Setter for field:
-     * {@snippet :
-     * int (*symlink)(char*,char*);
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*mkdir)(const char *, mode_t)
      * }
      */
-    public static void symlink$set(MemorySegment seg, MemorySegment x) {
-        constants$19.const$1.set(seg, x);
-    }
-    public static MemorySegment symlink$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$19.const$1.get(seg.asSlice(index*sizeof()));
-    }
-    public static void symlink$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$19.const$1.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static symlink symlink(MemorySegment segment, Arena scope) {
-        return symlink.ofAddress(symlink$get(segment), scope);
+    public static final AddressLayout mkdir$layout() {
+        return mkdir$LAYOUT;
     }
+
+    private static final long mkdir$OFFSET = 24;
+
     /**
-     * {@snippet :
- * int (*rename)(char*,char*,unsigned int);
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*mkdir)(const char *, mode_t)
      * }
      */
-    public interface rename {
-
-        int apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1, int _x2);
-        static MemorySegment allocate(rename fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$19.const$3, fi, constants$19.const$2, scope);
-        }
-        static rename ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1, int __x2) -> {
-                try {
-                    return (int)constants$19.const$4.invokeExact(symbol, __x0, __x1, __x2);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
-        }
+    public static final long mkdir$offset() {
+        return mkdir$OFFSET;
     }
 
-    public static VarHandle rename$VH() {
-        return constants$19.const$5;
-    }
     /**
      * Getter for field:
-     * {@snippet :
-     * int (*rename)(char*,char*,unsigned int);
+     * {@snippet lang=c :
+     * int (*mkdir)(const char *, mode_t)
      * }
      */
-    public static MemorySegment rename$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$19.const$5.get(seg);
+    public static MemorySegment mkdir(MemorySegment struct) {
+        return struct.get(mkdir$LAYOUT, mkdir$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int (*rename)(char*,char*,unsigned int);
+     * {@snippet lang=c :
+     * int (*mkdir)(const char *, mode_t)
      * }
      */
-    public static void rename$set(MemorySegment seg, MemorySegment x) {
-        constants$19.const$5.set(seg, x);
-    }
-    public static MemorySegment rename$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$19.const$5.get(seg.asSlice(index*sizeof()));
-    }
-    public static void rename$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$19.const$5.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static rename rename(MemorySegment segment, Arena scope) {
-        return rename.ofAddress(rename$get(segment), scope);
+    public static void mkdir(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(mkdir$LAYOUT, mkdir$OFFSET, fieldValue);
     }
+
     /**
-     * {@snippet :
- * int (*link)(char*,char*);
+     * {@snippet lang=c :
+     * int (*unlink)(const char *)
      * }
      */
-    public interface link {
+    public static class unlink {
 
-        int apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1);
-        static MemorySegment allocate(link fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$20.const$0, fi, constants$18.const$4, scope);
+        unlink() {
+            // Should not be called directly
         }
-        static link ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1) -> {
-                try {
-                    return (int)constants$19.const$0.invokeExact(symbol, __x0, __x1);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0);
         }
-    }
 
-    public static VarHandle link$VH() {
-        return constants$20.const$1;
-    }
-    /**
-     * Getter for field:
-     * {@snippet :
-     * int (*link)(char*,char*);
-     * }
-     */
-    public static MemorySegment link$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$20.const$1.get(seg);
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(unlink.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(unlink.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
     }
+
+    private static final AddressLayout unlink$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("unlink"));
+
     /**
-     * Setter for field:
-     * {@snippet :
-     * int (*link)(char*,char*);
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*unlink)(const char *)
      * }
      */
-    public static void link$set(MemorySegment seg, MemorySegment x) {
-        constants$20.const$1.set(seg, x);
-    }
-    public static MemorySegment link$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$20.const$1.get(seg.asSlice(index*sizeof()));
-    }
-    public static void link$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$20.const$1.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static link link(MemorySegment segment, Arena scope) {
-        return link.ofAddress(link$get(segment), scope);
+    public static final AddressLayout unlink$layout() {
+        return unlink$LAYOUT;
     }
+
+    private static final long unlink$OFFSET = 32;
+
     /**
-     * {@snippet :
- * int (*chmod)(char*,unsigned int,struct fuse_file_info*);
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*unlink)(const char *)
      * }
      */
-    public interface chmod {
-
-        int apply(java.lang.foreign.MemorySegment _x0, int _x1, java.lang.foreign.MemorySegment _x2);
-        static MemorySegment allocate(chmod fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$20.const$3, fi, constants$20.const$2, scope);
-        }
-        static chmod ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, int __x1, java.lang.foreign.MemorySegment __x2) -> {
-                try {
-                    return (int)constants$20.const$4.invokeExact(symbol, __x0, __x1, __x2);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
-        }
+    public static final long unlink$offset() {
+        return unlink$OFFSET;
     }
 
-    public static VarHandle chmod$VH() {
-        return constants$20.const$5;
-    }
     /**
      * Getter for field:
-     * {@snippet :
-     * int (*chmod)(char*,unsigned int,struct fuse_file_info*);
+     * {@snippet lang=c :
+     * int (*unlink)(const char *)
      * }
      */
-    public static MemorySegment chmod$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$20.const$5.get(seg);
+    public static MemorySegment unlink(MemorySegment struct) {
+        return struct.get(unlink$LAYOUT, unlink$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int (*chmod)(char*,unsigned int,struct fuse_file_info*);
+     * {@snippet lang=c :
+     * int (*unlink)(const char *)
      * }
      */
-    public static void chmod$set(MemorySegment seg, MemorySegment x) {
-        constants$20.const$5.set(seg, x);
-    }
-    public static MemorySegment chmod$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$20.const$5.get(seg.asSlice(index*sizeof()));
-    }
-    public static void chmod$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$20.const$5.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static chmod chmod(MemorySegment segment, Arena scope) {
-        return chmod.ofAddress(chmod$get(segment), scope);
+    public static void unlink(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(unlink$LAYOUT, unlink$OFFSET, fieldValue);
     }
+
     /**
-     * {@snippet :
- * int (*chown)(char*,unsigned int,unsigned int,struct fuse_file_info*);
+     * {@snippet lang=c :
+     * int (*rmdir)(const char *)
      * }
      */
-    public interface chown {
+    public static class rmdir {
 
-        int apply(java.lang.foreign.MemorySegment _x0, int _x1, int _x2, java.lang.foreign.MemorySegment _x3);
-        static MemorySegment allocate(chown fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$21.const$1, fi, constants$21.const$0, scope);
+        rmdir() {
+            // Should not be called directly
         }
-        static chown ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, int __x1, int __x2, java.lang.foreign.MemorySegment __x3) -> {
-                try {
-                    return (int)constants$21.const$2.invokeExact(symbol, __x0, __x1, __x2, __x3);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0);
         }
-    }
 
-    public static VarHandle chown$VH() {
-        return constants$21.const$3;
-    }
-    /**
-     * Getter for field:
-     * {@snippet :
-     * int (*chown)(char*,unsigned int,unsigned int,struct fuse_file_info*);
-     * }
-     */
-    public static MemorySegment chown$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$21.const$3.get(seg);
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(rmdir.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(rmdir.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
     }
+
+    private static final AddressLayout rmdir$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("rmdir"));
+
     /**
-     * Setter for field:
-     * {@snippet :
-     * int (*chown)(char*,unsigned int,unsigned int,struct fuse_file_info*);
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*rmdir)(const char *)
      * }
      */
-    public static void chown$set(MemorySegment seg, MemorySegment x) {
-        constants$21.const$3.set(seg, x);
-    }
-    public static MemorySegment chown$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$21.const$3.get(seg.asSlice(index*sizeof()));
-    }
-    public static void chown$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$21.const$3.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static chown chown(MemorySegment segment, Arena scope) {
-        return chown.ofAddress(chown$get(segment), scope);
+    public static final AddressLayout rmdir$layout() {
+        return rmdir$LAYOUT;
     }
+
+    private static final long rmdir$OFFSET = 40;
+
     /**
-     * {@snippet :
- * int (*truncate)(char*,long,struct fuse_file_info*);
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*rmdir)(const char *)
      * }
      */
-    public interface truncate {
-
-        int apply(java.lang.foreign.MemorySegment _x0, long _x1, java.lang.foreign.MemorySegment _x2);
-        static MemorySegment allocate(truncate fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$21.const$5, fi, constants$21.const$4, scope);
-        }
-        static truncate ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, long __x1, java.lang.foreign.MemorySegment __x2) -> {
-                try {
-                    return (int)constants$22.const$0.invokeExact(symbol, __x0, __x1, __x2);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
-        }
+    public static final long rmdir$offset() {
+        return rmdir$OFFSET;
     }
 
-    public static VarHandle truncate$VH() {
-        return constants$22.const$1;
-    }
     /**
      * Getter for field:
-     * {@snippet :
-     * int (*truncate)(char*,long,struct fuse_file_info*);
+     * {@snippet lang=c :
+     * int (*rmdir)(const char *)
      * }
      */
-    public static MemorySegment truncate$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$22.const$1.get(seg);
+    public static MemorySegment rmdir(MemorySegment struct) {
+        return struct.get(rmdir$LAYOUT, rmdir$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int (*truncate)(char*,long,struct fuse_file_info*);
+     * {@snippet lang=c :
+     * int (*rmdir)(const char *)
      * }
      */
-    public static void truncate$set(MemorySegment seg, MemorySegment x) {
-        constants$22.const$1.set(seg, x);
-    }
-    public static MemorySegment truncate$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$22.const$1.get(seg.asSlice(index*sizeof()));
-    }
-    public static void truncate$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$22.const$1.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static truncate truncate(MemorySegment segment, Arena scope) {
-        return truncate.ofAddress(truncate$get(segment), scope);
+    public static void rmdir(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(rmdir$LAYOUT, rmdir$OFFSET, fieldValue);
     }
+
     /**
-     * {@snippet :
- * int (*open)(char*,struct fuse_file_info*);
+     * {@snippet lang=c :
+     * int (*symlink)(const char *, const char *)
      * }
      */
-    public interface open {
+    public static class symlink {
 
-        int apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1);
-        static MemorySegment allocate(open fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$22.const$2, fi, constants$18.const$4, scope);
+        symlink() {
+            // Should not be called directly
         }
-        static open ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1) -> {
-                try {
-                    return (int)constants$19.const$0.invokeExact(symbol, __x0, __x1);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, MemorySegment _x1);
         }
-    }
 
-    public static VarHandle open$VH() {
-        return constants$22.const$3;
-    }
-    /**
-     * Getter for field:
-     * {@snippet :
-     * int (*open)(char*,struct fuse_file_info*);
-     * }
-     */
-    public static MemorySegment open$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$22.const$3.get(seg);
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(symlink.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(symlink.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
     }
+
+    private static final AddressLayout symlink$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("symlink"));
+
     /**
-     * Setter for field:
-     * {@snippet :
-     * int (*open)(char*,struct fuse_file_info*);
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*symlink)(const char *, const char *)
      * }
      */
-    public static void open$set(MemorySegment seg, MemorySegment x) {
-        constants$22.const$3.set(seg, x);
-    }
-    public static MemorySegment open$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$22.const$3.get(seg.asSlice(index*sizeof()));
-    }
-    public static void open$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$22.const$3.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static open open(MemorySegment segment, Arena scope) {
-        return open.ofAddress(open$get(segment), scope);
+    public static final AddressLayout symlink$layout() {
+        return symlink$LAYOUT;
     }
+
+    private static final long symlink$OFFSET = 48;
+
     /**
-     * {@snippet :
- * int (*read)(char*,char*,unsigned long,long,struct fuse_file_info*);
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*symlink)(const char *, const char *)
      * }
      */
-    public interface read {
-
-        int apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1, long _x2, long _x3, java.lang.foreign.MemorySegment _x4);
-        static MemorySegment allocate(read fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$22.const$5, fi, constants$22.const$4, scope);
-        }
-        static read ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1, long __x2, long __x3, java.lang.foreign.MemorySegment __x4) -> {
-                try {
-                    return (int)constants$23.const$0.invokeExact(symbol, __x0, __x1, __x2, __x3, __x4);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
-        }
+    public static final long symlink$offset() {
+        return symlink$OFFSET;
     }
 
-    public static VarHandle read$VH() {
-        return constants$23.const$1;
-    }
     /**
      * Getter for field:
-     * {@snippet :
-     * int (*read)(char*,char*,unsigned long,long,struct fuse_file_info*);
+     * {@snippet lang=c :
+     * int (*symlink)(const char *, const char *)
      * }
      */
-    public static MemorySegment read$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$23.const$1.get(seg);
+    public static MemorySegment symlink(MemorySegment struct) {
+        return struct.get(symlink$LAYOUT, symlink$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int (*read)(char*,char*,unsigned long,long,struct fuse_file_info*);
+     * {@snippet lang=c :
+     * int (*symlink)(const char *, const char *)
      * }
      */
-    public static void read$set(MemorySegment seg, MemorySegment x) {
-        constants$23.const$1.set(seg, x);
-    }
-    public static MemorySegment read$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$23.const$1.get(seg.asSlice(index*sizeof()));
-    }
-    public static void read$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$23.const$1.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static read read(MemorySegment segment, Arena scope) {
-        return read.ofAddress(read$get(segment), scope);
+    public static void symlink(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(symlink$LAYOUT, symlink$OFFSET, fieldValue);
     }
+
     /**
-     * {@snippet :
- * int (*write)(char*,char*,unsigned long,long,struct fuse_file_info*);
+     * {@snippet lang=c :
+     * int (*rename)(const char *, const char *, unsigned int)
      * }
      */
-    public interface write {
+    public static class rename {
+
+        rename() {
+            // Should not be called directly
+        }
 
-        int apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1, long _x2, long _x3, java.lang.foreign.MemorySegment _x4);
-        static MemorySegment allocate(write fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$23.const$2, fi, constants$22.const$4, scope);
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, MemorySegment _x1, int _x2);
         }
-        static write ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1, long __x2, long __x3, java.lang.foreign.MemorySegment __x4) -> {
-                try {
-                    return (int)constants$23.const$0.invokeExact(symbol, __x0, __x1, __x2, __x3, __x4);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER,
+            fuse_h.C_INT
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
         }
-    }
 
-    public static VarHandle write$VH() {
-        return constants$23.const$3;
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(rename.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(rename.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1, int _x2) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
     }
+
+    private static final AddressLayout rename$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("rename"));
+
     /**
-     * Getter for field:
-     * {@snippet :
-     * int (*write)(char*,char*,unsigned long,long,struct fuse_file_info*);
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*rename)(const char *, const char *, unsigned int)
      * }
      */
-    public static MemorySegment write$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$23.const$3.get(seg);
+    public static final AddressLayout rename$layout() {
+        return rename$LAYOUT;
     }
+
+    private static final long rename$OFFSET = 56;
+
     /**
-     * Setter for field:
-     * {@snippet :
-     * int (*write)(char*,char*,unsigned long,long,struct fuse_file_info*);
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*rename)(const char *, const char *, unsigned int)
      * }
      */
-    public static void write$set(MemorySegment seg, MemorySegment x) {
-        constants$23.const$3.set(seg, x);
-    }
-    public static MemorySegment write$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$23.const$3.get(seg.asSlice(index*sizeof()));
-    }
-    public static void write$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$23.const$3.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static write write(MemorySegment segment, Arena scope) {
-        return write.ofAddress(write$get(segment), scope);
+    public static final long rename$offset() {
+        return rename$OFFSET;
     }
+
     /**
-     * {@snippet :
- * int (*statfs)(char*,struct statvfs*);
+     * Getter for field:
+     * {@snippet lang=c :
+     * int (*rename)(const char *, const char *, unsigned int)
      * }
      */
-    public interface statfs {
-
-        int apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1);
-        static MemorySegment allocate(statfs fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$23.const$4, fi, constants$18.const$4, scope);
-        }
-        static statfs ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1) -> {
-                try {
-                    return (int)constants$19.const$0.invokeExact(symbol, __x0, __x1);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
-        }
+    public static MemorySegment rename(MemorySegment struct) {
+        return struct.get(rename$LAYOUT, rename$OFFSET);
     }
 
-    public static VarHandle statfs$VH() {
-        return constants$23.const$5;
-    }
-    /**
-     * Getter for field:
-     * {@snippet :
-     * int (*statfs)(char*,struct statvfs*);
-     * }
-     */
-    public static MemorySegment statfs$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$23.const$5.get(seg);
-    }
     /**
      * Setter for field:
-     * {@snippet :
-     * int (*statfs)(char*,struct statvfs*);
+     * {@snippet lang=c :
+     * int (*rename)(const char *, const char *, unsigned int)
      * }
      */
-    public static void statfs$set(MemorySegment seg, MemorySegment x) {
-        constants$23.const$5.set(seg, x);
-    }
-    public static MemorySegment statfs$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$23.const$5.get(seg.asSlice(index*sizeof()));
-    }
-    public static void statfs$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$23.const$5.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static statfs statfs(MemorySegment segment, Arena scope) {
-        return statfs.ofAddress(statfs$get(segment), scope);
+    public static void rename(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(rename$LAYOUT, rename$OFFSET, fieldValue);
     }
+
     /**
-     * {@snippet :
- * int (*flush)(char*,struct fuse_file_info*);
+     * {@snippet lang=c :
+     * int (*link)(const char *, const char *)
      * }
      */
-    public interface flush {
+    public static class link {
+
+        link() {
+            // Should not be called directly
+        }
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, MemorySegment _x1);
+        }
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
 
-        int apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1);
-        static MemorySegment allocate(flush fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$24.const$0, fi, constants$18.const$4, scope);
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(link.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(link.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
         }
-        static flush ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1) -> {
-                try {
-                    return (int)constants$19.const$0.invokeExact(symbol, __x0, __x1);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
         }
     }
 
-    public static VarHandle flush$VH() {
-        return constants$24.const$1;
+    private static final AddressLayout link$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("link"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*link)(const char *, const char *)
+     * }
+     */
+    public static final AddressLayout link$layout() {
+        return link$LAYOUT;
+    }
+
+    private static final long link$OFFSET = 64;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*link)(const char *, const char *)
+     * }
+     */
+    public static final long link$offset() {
+        return link$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int (*flush)(char*,struct fuse_file_info*);
+     * {@snippet lang=c :
+     * int (*link)(const char *, const char *)
      * }
      */
-    public static MemorySegment flush$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$24.const$1.get(seg);
+    public static MemorySegment link(MemorySegment struct) {
+        return struct.get(link$LAYOUT, link$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int (*flush)(char*,struct fuse_file_info*);
+     * {@snippet lang=c :
+     * int (*link)(const char *, const char *)
      * }
      */
-    public static void flush$set(MemorySegment seg, MemorySegment x) {
-        constants$24.const$1.set(seg, x);
-    }
-    public static MemorySegment flush$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$24.const$1.get(seg.asSlice(index*sizeof()));
-    }
-    public static void flush$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$24.const$1.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static flush flush(MemorySegment segment, Arena scope) {
-        return flush.ofAddress(flush$get(segment), scope);
+    public static void link(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(link$LAYOUT, link$OFFSET, fieldValue);
     }
+
     /**
-     * {@snippet :
- * int (*release)(char*,struct fuse_file_info*);
+     * {@snippet lang=c :
+     * int (*chmod)(const char *, mode_t, struct fuse_file_info *)
      * }
      */
-    public interface release {
+    public static class chmod {
+
+        chmod() {
+            // Should not be called directly
+        }
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, int _x1, MemorySegment _x2);
+        }
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_INT,
+            fuse_h.C_POINTER
+        );
 
-        int apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1);
-        static MemorySegment allocate(release fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$24.const$2, fi, constants$18.const$4, scope);
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
         }
-        static release ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1) -> {
-                try {
-                    return (int)constants$19.const$0.invokeExact(symbol, __x0, __x1);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(chmod.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(chmod.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, int _x1, MemorySegment _x2) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
         }
     }
 
-    public static VarHandle release$VH() {
-        return constants$24.const$3;
+    private static final AddressLayout chmod$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("chmod"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*chmod)(const char *, mode_t, struct fuse_file_info *)
+     * }
+     */
+    public static final AddressLayout chmod$layout() {
+        return chmod$LAYOUT;
+    }
+
+    private static final long chmod$OFFSET = 72;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*chmod)(const char *, mode_t, struct fuse_file_info *)
+     * }
+     */
+    public static final long chmod$offset() {
+        return chmod$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int (*release)(char*,struct fuse_file_info*);
+     * {@snippet lang=c :
+     * int (*chmod)(const char *, mode_t, struct fuse_file_info *)
      * }
      */
-    public static MemorySegment release$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$24.const$3.get(seg);
+    public static MemorySegment chmod(MemorySegment struct) {
+        return struct.get(chmod$LAYOUT, chmod$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int (*release)(char*,struct fuse_file_info*);
+     * {@snippet lang=c :
+     * int (*chmod)(const char *, mode_t, struct fuse_file_info *)
      * }
      */
-    public static void release$set(MemorySegment seg, MemorySegment x) {
-        constants$24.const$3.set(seg, x);
-    }
-    public static MemorySegment release$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$24.const$3.get(seg.asSlice(index*sizeof()));
-    }
-    public static void release$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$24.const$3.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static release release(MemorySegment segment, Arena scope) {
-        return release.ofAddress(release$get(segment), scope);
+    public static void chmod(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(chmod$LAYOUT, chmod$OFFSET, fieldValue);
     }
+
     /**
-     * {@snippet :
- * int (*fsync)(char*,int,struct fuse_file_info*);
+     * {@snippet lang=c :
+     * int (*chown)(const char *, uid_t, gid_t, struct fuse_file_info *)
      * }
      */
-    public interface fsync {
+    public static class chown {
+
+        chown() {
+            // Should not be called directly
+        }
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, int _x1, int _x2, MemorySegment _x3);
+        }
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_INT,
+            fuse_h.C_INT,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
 
-        int apply(java.lang.foreign.MemorySegment _x0, int _x1, java.lang.foreign.MemorySegment _x2);
-        static MemorySegment allocate(fsync fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$24.const$4, fi, constants$20.const$2, scope);
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(chown.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(chown.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
         }
-        static fsync ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, int __x1, java.lang.foreign.MemorySegment __x2) -> {
-                try {
-                    return (int)constants$20.const$4.invokeExact(symbol, __x0, __x1, __x2);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, int _x1, int _x2, MemorySegment _x3) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2, _x3);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
         }
     }
 
-    public static VarHandle fsync$VH() {
-        return constants$24.const$5;
+    private static final AddressLayout chown$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("chown"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*chown)(const char *, uid_t, gid_t, struct fuse_file_info *)
+     * }
+     */
+    public static final AddressLayout chown$layout() {
+        return chown$LAYOUT;
+    }
+
+    private static final long chown$OFFSET = 80;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*chown)(const char *, uid_t, gid_t, struct fuse_file_info *)
+     * }
+     */
+    public static final long chown$offset() {
+        return chown$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int (*fsync)(char*,int,struct fuse_file_info*);
+     * {@snippet lang=c :
+     * int (*chown)(const char *, uid_t, gid_t, struct fuse_file_info *)
      * }
      */
-    public static MemorySegment fsync$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$24.const$5.get(seg);
+    public static MemorySegment chown(MemorySegment struct) {
+        return struct.get(chown$LAYOUT, chown$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int (*fsync)(char*,int,struct fuse_file_info*);
+     * {@snippet lang=c :
+     * int (*chown)(const char *, uid_t, gid_t, struct fuse_file_info *)
      * }
      */
-    public static void fsync$set(MemorySegment seg, MemorySegment x) {
-        constants$24.const$5.set(seg, x);
-    }
-    public static MemorySegment fsync$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$24.const$5.get(seg.asSlice(index*sizeof()));
-    }
-    public static void fsync$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$24.const$5.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static fsync fsync(MemorySegment segment, Arena scope) {
-        return fsync.ofAddress(fsync$get(segment), scope);
+    public static void chown(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(chown$LAYOUT, chown$OFFSET, fieldValue);
     }
+
     /**
-     * {@snippet :
- * int (*setxattr)(char*,char*,char*,unsigned long,int);
+     * {@snippet lang=c :
+     * int (*truncate)(const char *, off_t, struct fuse_file_info *)
      * }
      */
-    public interface setxattr {
+    public static class truncate {
+
+        truncate() {
+            // Should not be called directly
+        }
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, long _x1, MemorySegment _x2);
+        }
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_LONG,
+            fuse_h.C_POINTER
+        );
 
-        int apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1, java.lang.foreign.MemorySegment _x2, long _x3, int _x4);
-        static MemorySegment allocate(setxattr fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$25.const$0, fi, constants$10.const$0, scope);
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
         }
-        static setxattr ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1, java.lang.foreign.MemorySegment __x2, long __x3, int __x4) -> {
-                try {
-                    return (int)constants$10.const$2.invokeExact(symbol, __x0, __x1, __x2, __x3, __x4);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(truncate.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(truncate.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, long _x1, MemorySegment _x2) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
         }
     }
 
-    public static VarHandle setxattr$VH() {
-        return constants$25.const$1;
+    private static final AddressLayout truncate$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("truncate"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*truncate)(const char *, off_t, struct fuse_file_info *)
+     * }
+     */
+    public static final AddressLayout truncate$layout() {
+        return truncate$LAYOUT;
+    }
+
+    private static final long truncate$OFFSET = 88;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*truncate)(const char *, off_t, struct fuse_file_info *)
+     * }
+     */
+    public static final long truncate$offset() {
+        return truncate$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int (*setxattr)(char*,char*,char*,unsigned long,int);
+     * {@snippet lang=c :
+     * int (*truncate)(const char *, off_t, struct fuse_file_info *)
      * }
      */
-    public static MemorySegment setxattr$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$25.const$1.get(seg);
+    public static MemorySegment truncate(MemorySegment struct) {
+        return struct.get(truncate$LAYOUT, truncate$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int (*setxattr)(char*,char*,char*,unsigned long,int);
+     * {@snippet lang=c :
+     * int (*truncate)(const char *, off_t, struct fuse_file_info *)
      * }
      */
-    public static void setxattr$set(MemorySegment seg, MemorySegment x) {
-        constants$25.const$1.set(seg, x);
-    }
-    public static MemorySegment setxattr$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$25.const$1.get(seg.asSlice(index*sizeof()));
-    }
-    public static void setxattr$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$25.const$1.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static setxattr setxattr(MemorySegment segment, Arena scope) {
-        return setxattr.ofAddress(setxattr$get(segment), scope);
+    public static void truncate(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(truncate$LAYOUT, truncate$OFFSET, fieldValue);
     }
+
     /**
-     * {@snippet :
- * int (*getxattr)(char*,char*,char*,unsigned long);
+     * {@snippet lang=c :
+     * int (*open)(const char *, struct fuse_file_info *)
      * }
      */
-    public interface getxattr {
+    public static class open {
+
+        open() {
+            // Should not be called directly
+        }
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, MemorySegment _x1);
+        }
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
 
-        int apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1, java.lang.foreign.MemorySegment _x2, long _x3);
-        static MemorySegment allocate(getxattr fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$25.const$3, fi, constants$25.const$2, scope);
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(open.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(open.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
         }
-        static getxattr ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1, java.lang.foreign.MemorySegment __x2, long __x3) -> {
-                try {
-                    return (int)constants$25.const$4.invokeExact(symbol, __x0, __x1, __x2, __x3);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
         }
     }
 
-    public static VarHandle getxattr$VH() {
-        return constants$25.const$5;
+    private static final AddressLayout open$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("open"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*open)(const char *, struct fuse_file_info *)
+     * }
+     */
+    public static final AddressLayout open$layout() {
+        return open$LAYOUT;
+    }
+
+    private static final long open$OFFSET = 96;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*open)(const char *, struct fuse_file_info *)
+     * }
+     */
+    public static final long open$offset() {
+        return open$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int (*getxattr)(char*,char*,char*,unsigned long);
+     * {@snippet lang=c :
+     * int (*open)(const char *, struct fuse_file_info *)
      * }
      */
-    public static MemorySegment getxattr$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$25.const$5.get(seg);
+    public static MemorySegment open(MemorySegment struct) {
+        return struct.get(open$LAYOUT, open$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int (*getxattr)(char*,char*,char*,unsigned long);
+     * {@snippet lang=c :
+     * int (*open)(const char *, struct fuse_file_info *)
      * }
      */
-    public static void getxattr$set(MemorySegment seg, MemorySegment x) {
-        constants$25.const$5.set(seg, x);
-    }
-    public static MemorySegment getxattr$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$25.const$5.get(seg.asSlice(index*sizeof()));
-    }
-    public static void getxattr$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$25.const$5.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static getxattr getxattr(MemorySegment segment, Arena scope) {
-        return getxattr.ofAddress(getxattr$get(segment), scope);
+    public static void open(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(open$LAYOUT, open$OFFSET, fieldValue);
     }
+
     /**
-     * {@snippet :
- * int (*listxattr)(char*,char*,unsigned long);
+     * {@snippet lang=c :
+     * int (*read)(const char *, char *, size_t, off_t, struct fuse_file_info *)
      * }
      */
-    public interface listxattr {
+    public static class read {
+
+        read() {
+            // Should not be called directly
+        }
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, MemorySegment _x1, long _x2, long _x3, MemorySegment _x4);
+        }
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER,
+            fuse_h.C_LONG,
+            fuse_h.C_LONG,
+            fuse_h.C_POINTER
+        );
 
-        int apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1, long _x2);
-        static MemorySegment allocate(listxattr fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$26.const$0, fi, constants$15.const$4, scope);
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
         }
-        static listxattr ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1, long __x2) -> {
-                try {
-                    return (int)constants$16.const$0.invokeExact(symbol, __x0, __x1, __x2);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(read.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(read.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1, long _x2, long _x3, MemorySegment _x4) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2, _x3, _x4);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
         }
     }
 
-    public static VarHandle listxattr$VH() {
-        return constants$26.const$1;
+    private static final AddressLayout read$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("read"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*read)(const char *, char *, size_t, off_t, struct fuse_file_info *)
+     * }
+     */
+    public static final AddressLayout read$layout() {
+        return read$LAYOUT;
+    }
+
+    private static final long read$OFFSET = 104;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*read)(const char *, char *, size_t, off_t, struct fuse_file_info *)
+     * }
+     */
+    public static final long read$offset() {
+        return read$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int (*listxattr)(char*,char*,unsigned long);
+     * {@snippet lang=c :
+     * int (*read)(const char *, char *, size_t, off_t, struct fuse_file_info *)
      * }
      */
-    public static MemorySegment listxattr$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$26.const$1.get(seg);
+    public static MemorySegment read(MemorySegment struct) {
+        return struct.get(read$LAYOUT, read$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int (*listxattr)(char*,char*,unsigned long);
+     * {@snippet lang=c :
+     * int (*read)(const char *, char *, size_t, off_t, struct fuse_file_info *)
      * }
      */
-    public static void listxattr$set(MemorySegment seg, MemorySegment x) {
-        constants$26.const$1.set(seg, x);
-    }
-    public static MemorySegment listxattr$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$26.const$1.get(seg.asSlice(index*sizeof()));
-    }
-    public static void listxattr$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$26.const$1.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static listxattr listxattr(MemorySegment segment, Arena scope) {
-        return listxattr.ofAddress(listxattr$get(segment), scope);
+    public static void read(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(read$LAYOUT, read$OFFSET, fieldValue);
     }
+
     /**
-     * {@snippet :
- * int (*removexattr)(char*,char*);
+     * {@snippet lang=c :
+     * int (*write)(const char *, const char *, size_t, off_t, struct fuse_file_info *)
      * }
      */
-    public interface removexattr {
+    public static class write {
+
+        write() {
+            // Should not be called directly
+        }
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, MemorySegment _x1, long _x2, long _x3, MemorySegment _x4);
+        }
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER,
+            fuse_h.C_LONG,
+            fuse_h.C_LONG,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
 
-        int apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1);
-        static MemorySegment allocate(removexattr fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$26.const$2, fi, constants$18.const$4, scope);
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(write.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(write.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
         }
-        static removexattr ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1) -> {
-                try {
-                    return (int)constants$19.const$0.invokeExact(symbol, __x0, __x1);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1, long _x2, long _x3, MemorySegment _x4) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2, _x3, _x4);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
         }
     }
 
-    public static VarHandle removexattr$VH() {
-        return constants$26.const$3;
+    private static final AddressLayout write$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("write"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*write)(const char *, const char *, size_t, off_t, struct fuse_file_info *)
+     * }
+     */
+    public static final AddressLayout write$layout() {
+        return write$LAYOUT;
+    }
+
+    private static final long write$OFFSET = 112;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*write)(const char *, const char *, size_t, off_t, struct fuse_file_info *)
+     * }
+     */
+    public static final long write$offset() {
+        return write$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int (*removexattr)(char*,char*);
+     * {@snippet lang=c :
+     * int (*write)(const char *, const char *, size_t, off_t, struct fuse_file_info *)
      * }
      */
-    public static MemorySegment removexattr$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$26.const$3.get(seg);
+    public static MemorySegment write(MemorySegment struct) {
+        return struct.get(write$LAYOUT, write$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int (*removexattr)(char*,char*);
+     * {@snippet lang=c :
+     * int (*write)(const char *, const char *, size_t, off_t, struct fuse_file_info *)
      * }
      */
-    public static void removexattr$set(MemorySegment seg, MemorySegment x) {
-        constants$26.const$3.set(seg, x);
-    }
-    public static MemorySegment removexattr$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$26.const$3.get(seg.asSlice(index*sizeof()));
-    }
-    public static void removexattr$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$26.const$3.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static removexattr removexattr(MemorySegment segment, Arena scope) {
-        return removexattr.ofAddress(removexattr$get(segment), scope);
+    public static void write(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(write$LAYOUT, write$OFFSET, fieldValue);
     }
+
     /**
-     * {@snippet :
- * int (*opendir)(char*,struct fuse_file_info*);
+     * {@snippet lang=c :
+     * int (*statfs)(const char *, struct statvfs *)
      * }
      */
-    public interface opendir {
+    public static class statfs {
+
+        statfs() {
+            // Should not be called directly
+        }
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, MemorySegment _x1);
+        }
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER
+        );
 
-        int apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1);
-        static MemorySegment allocate(opendir fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$26.const$4, fi, constants$18.const$4, scope);
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
         }
-        static opendir ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1) -> {
-                try {
-                    return (int)constants$19.const$0.invokeExact(symbol, __x0, __x1);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(statfs.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(statfs.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
         }
     }
 
-    public static VarHandle opendir$VH() {
-        return constants$26.const$5;
+    private static final AddressLayout statfs$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("statfs"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*statfs)(const char *, struct statvfs *)
+     * }
+     */
+    public static final AddressLayout statfs$layout() {
+        return statfs$LAYOUT;
+    }
+
+    private static final long statfs$OFFSET = 120;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*statfs)(const char *, struct statvfs *)
+     * }
+     */
+    public static final long statfs$offset() {
+        return statfs$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int (*opendir)(char*,struct fuse_file_info*);
+     * {@snippet lang=c :
+     * int (*statfs)(const char *, struct statvfs *)
      * }
      */
-    public static MemorySegment opendir$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$26.const$5.get(seg);
+    public static MemorySegment statfs(MemorySegment struct) {
+        return struct.get(statfs$LAYOUT, statfs$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int (*opendir)(char*,struct fuse_file_info*);
+     * {@snippet lang=c :
+     * int (*statfs)(const char *, struct statvfs *)
      * }
      */
-    public static void opendir$set(MemorySegment seg, MemorySegment x) {
-        constants$26.const$5.set(seg, x);
-    }
-    public static MemorySegment opendir$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$26.const$5.get(seg.asSlice(index*sizeof()));
-    }
-    public static void opendir$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$26.const$5.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static opendir opendir(MemorySegment segment, Arena scope) {
-        return opendir.ofAddress(opendir$get(segment), scope);
+    public static void statfs(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(statfs$LAYOUT, statfs$OFFSET, fieldValue);
     }
+
     /**
-     * {@snippet :
- * int (*readdir)(char*,void*,int (*)(void*,char*,struct stat*,long,enum fuse_fill_dir_flags),long,struct fuse_file_info*,enum fuse_readdir_flags);
+     * {@snippet lang=c :
+     * int (*flush)(const char *, struct fuse_file_info *)
      * }
      */
-    public interface readdir {
+    public static class flush {
 
-        int apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1, java.lang.foreign.MemorySegment _x2, long _x3, java.lang.foreign.MemorySegment _x4, int _x5);
-        static MemorySegment allocate(readdir fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$27.const$1, fi, constants$27.const$0, scope);
+        flush() {
+            // Should not be called directly
         }
-        static readdir ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1, java.lang.foreign.MemorySegment __x2, long __x3, java.lang.foreign.MemorySegment __x4, int __x5) -> {
-                try {
-                    return (int)constants$27.const$2.invokeExact(symbol, __x0, __x1, __x2, __x3, __x4, __x5);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, MemorySegment _x1);
         }
-    }
 
-    public static VarHandle readdir$VH() {
-        return constants$27.const$3;
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(flush.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(flush.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
     }
+
+    private static final AddressLayout flush$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("flush"));
+
     /**
-     * Getter for field:
-     * {@snippet :
-     * int (*readdir)(char*,void*,int (*)(void*,char*,struct stat*,long,enum fuse_fill_dir_flags),long,struct fuse_file_info*,enum fuse_readdir_flags);
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*flush)(const char *, struct fuse_file_info *)
      * }
      */
-    public static MemorySegment readdir$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$27.const$3.get(seg);
+    public static final AddressLayout flush$layout() {
+        return flush$LAYOUT;
     }
+
+    private static final long flush$OFFSET = 128;
+
     /**
-     * Setter for field:
-     * {@snippet :
-     * int (*readdir)(char*,void*,int (*)(void*,char*,struct stat*,long,enum fuse_fill_dir_flags),long,struct fuse_file_info*,enum fuse_readdir_flags);
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*flush)(const char *, struct fuse_file_info *)
      * }
      */
-    public static void readdir$set(MemorySegment seg, MemorySegment x) {
-        constants$27.const$3.set(seg, x);
-    }
-    public static MemorySegment readdir$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$27.const$3.get(seg.asSlice(index*sizeof()));
-    }
-    public static void readdir$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$27.const$3.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static readdir readdir(MemorySegment segment, Arena scope) {
-        return readdir.ofAddress(readdir$get(segment), scope);
+    public static final long flush$offset() {
+        return flush$OFFSET;
     }
+
     /**
-     * {@snippet :
- * int (*releasedir)(char*,struct fuse_file_info*);
+     * Getter for field:
+     * {@snippet lang=c :
+     * int (*flush)(const char *, struct fuse_file_info *)
      * }
      */
-    public interface releasedir {
-
-        int apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1);
-        static MemorySegment allocate(releasedir fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$27.const$4, fi, constants$18.const$4, scope);
-        }
-        static releasedir ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1) -> {
-                try {
-                    return (int)constants$19.const$0.invokeExact(symbol, __x0, __x1);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
-        }
+    public static MemorySegment flush(MemorySegment struct) {
+        return struct.get(flush$LAYOUT, flush$OFFSET);
     }
 
-    public static VarHandle releasedir$VH() {
-        return constants$27.const$5;
-    }
     /**
-     * Getter for field:
-     * {@snippet :
-     * int (*releasedir)(char*,struct fuse_file_info*);
+     * Setter for field:
+     * {@snippet lang=c :
+     * int (*flush)(const char *, struct fuse_file_info *)
      * }
      */
-    public static MemorySegment releasedir$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$27.const$5.get(seg);
+    public static void flush(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(flush$LAYOUT, flush$OFFSET, fieldValue);
     }
+
     /**
-     * Setter for field:
-     * {@snippet :
-     * int (*releasedir)(char*,struct fuse_file_info*);
+     * {@snippet lang=c :
+     * int (*release)(const char *, struct fuse_file_info *)
      * }
      */
-    public static void releasedir$set(MemorySegment seg, MemorySegment x) {
-        constants$27.const$5.set(seg, x);
-    }
-    public static MemorySegment releasedir$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$27.const$5.get(seg.asSlice(index*sizeof()));
-    }
-    public static void releasedir$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$27.const$5.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static releasedir releasedir(MemorySegment segment, Arena scope) {
-        return releasedir.ofAddress(releasedir$get(segment), scope);
+    public static class release {
+
+        release() {
+            // Should not be called directly
+        }
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, MemorySegment _x1);
+        }
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(release.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(release.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
+    }
+
+    private static final AddressLayout release$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("release"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*release)(const char *, struct fuse_file_info *)
+     * }
+     */
+    public static final AddressLayout release$layout() {
+        return release$LAYOUT;
+    }
+
+    private static final long release$OFFSET = 136;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*release)(const char *, struct fuse_file_info *)
+     * }
+     */
+    public static final long release$offset() {
+        return release$OFFSET;
+    }
+
+    /**
+     * Getter for field:
+     * {@snippet lang=c :
+     * int (*release)(const char *, struct fuse_file_info *)
+     * }
+     */
+    public static MemorySegment release(MemorySegment struct) {
+        return struct.get(release$LAYOUT, release$OFFSET);
+    }
+
+    /**
+     * Setter for field:
+     * {@snippet lang=c :
+     * int (*release)(const char *, struct fuse_file_info *)
+     * }
+     */
+    public static void release(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(release$LAYOUT, release$OFFSET, fieldValue);
+    }
+
+    /**
+     * {@snippet lang=c :
+     * int (*fsync)(const char *, int, struct fuse_file_info *)
+     * }
+     */
+    public static class fsync {
+
+        fsync() {
+            // Should not be called directly
+        }
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, int _x1, MemorySegment _x2);
+        }
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_INT,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(fsync.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(fsync.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, int _x1, MemorySegment _x2) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
+    }
+
+    private static final AddressLayout fsync$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("fsync"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*fsync)(const char *, int, struct fuse_file_info *)
+     * }
+     */
+    public static final AddressLayout fsync$layout() {
+        return fsync$LAYOUT;
+    }
+
+    private static final long fsync$OFFSET = 144;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*fsync)(const char *, int, struct fuse_file_info *)
+     * }
+     */
+    public static final long fsync$offset() {
+        return fsync$OFFSET;
+    }
+
+    /**
+     * Getter for field:
+     * {@snippet lang=c :
+     * int (*fsync)(const char *, int, struct fuse_file_info *)
+     * }
+     */
+    public static MemorySegment fsync(MemorySegment struct) {
+        return struct.get(fsync$LAYOUT, fsync$OFFSET);
+    }
+
+    /**
+     * Setter for field:
+     * {@snippet lang=c :
+     * int (*fsync)(const char *, int, struct fuse_file_info *)
+     * }
+     */
+    public static void fsync(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(fsync$LAYOUT, fsync$OFFSET, fieldValue);
+    }
+
+    /**
+     * {@snippet lang=c :
+     * int (*setxattr)(const char *, const char *, const char *, size_t, int)
+     * }
+     */
+    public static class setxattr {
+
+        setxattr() {
+            // Should not be called directly
+        }
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, MemorySegment _x1, MemorySegment _x2, long _x3, int _x4);
+        }
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER,
+            fuse_h.C_LONG,
+            fuse_h.C_INT
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(setxattr.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(setxattr.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1, MemorySegment _x2, long _x3, int _x4) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2, _x3, _x4);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
+    }
+
+    private static final AddressLayout setxattr$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("setxattr"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*setxattr)(const char *, const char *, const char *, size_t, int)
+     * }
+     */
+    public static final AddressLayout setxattr$layout() {
+        return setxattr$LAYOUT;
+    }
+
+    private static final long setxattr$OFFSET = 152;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*setxattr)(const char *, const char *, const char *, size_t, int)
+     * }
+     */
+    public static final long setxattr$offset() {
+        return setxattr$OFFSET;
+    }
+
+    /**
+     * Getter for field:
+     * {@snippet lang=c :
+     * int (*setxattr)(const char *, const char *, const char *, size_t, int)
+     * }
+     */
+    public static MemorySegment setxattr(MemorySegment struct) {
+        return struct.get(setxattr$LAYOUT, setxattr$OFFSET);
+    }
+
+    /**
+     * Setter for field:
+     * {@snippet lang=c :
+     * int (*setxattr)(const char *, const char *, const char *, size_t, int)
+     * }
+     */
+    public static void setxattr(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(setxattr$LAYOUT, setxattr$OFFSET, fieldValue);
+    }
+
+    /**
+     * {@snippet lang=c :
+     * int (*getxattr)(const char *, const char *, char *, size_t)
+     * }
+     */
+    public static class getxattr {
+
+        getxattr() {
+            // Should not be called directly
+        }
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, MemorySegment _x1, MemorySegment _x2, long _x3);
+        }
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER,
+            fuse_h.C_LONG
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(getxattr.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(getxattr.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1, MemorySegment _x2, long _x3) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2, _x3);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
+    }
+
+    private static final AddressLayout getxattr$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("getxattr"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*getxattr)(const char *, const char *, char *, size_t)
+     * }
+     */
+    public static final AddressLayout getxattr$layout() {
+        return getxattr$LAYOUT;
+    }
+
+    private static final long getxattr$OFFSET = 160;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*getxattr)(const char *, const char *, char *, size_t)
+     * }
+     */
+    public static final long getxattr$offset() {
+        return getxattr$OFFSET;
+    }
+
+    /**
+     * Getter for field:
+     * {@snippet lang=c :
+     * int (*getxattr)(const char *, const char *, char *, size_t)
+     * }
+     */
+    public static MemorySegment getxattr(MemorySegment struct) {
+        return struct.get(getxattr$LAYOUT, getxattr$OFFSET);
+    }
+
+    /**
+     * Setter for field:
+     * {@snippet lang=c :
+     * int (*getxattr)(const char *, const char *, char *, size_t)
+     * }
+     */
+    public static void getxattr(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(getxattr$LAYOUT, getxattr$OFFSET, fieldValue);
+    }
+
+    /**
+     * {@snippet lang=c :
+     * int (*listxattr)(const char *, char *, size_t)
+     * }
+     */
+    public static class listxattr {
+
+        listxattr() {
+            // Should not be called directly
+        }
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, MemorySegment _x1, long _x2);
+        }
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER,
+            fuse_h.C_LONG
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(listxattr.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(listxattr.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1, long _x2) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
+    }
+
+    private static final AddressLayout listxattr$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("listxattr"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*listxattr)(const char *, char *, size_t)
+     * }
+     */
+    public static final AddressLayout listxattr$layout() {
+        return listxattr$LAYOUT;
+    }
+
+    private static final long listxattr$OFFSET = 168;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*listxattr)(const char *, char *, size_t)
+     * }
+     */
+    public static final long listxattr$offset() {
+        return listxattr$OFFSET;
+    }
+
+    /**
+     * Getter for field:
+     * {@snippet lang=c :
+     * int (*listxattr)(const char *, char *, size_t)
+     * }
+     */
+    public static MemorySegment listxattr(MemorySegment struct) {
+        return struct.get(listxattr$LAYOUT, listxattr$OFFSET);
+    }
+
+    /**
+     * Setter for field:
+     * {@snippet lang=c :
+     * int (*listxattr)(const char *, char *, size_t)
+     * }
+     */
+    public static void listxattr(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(listxattr$LAYOUT, listxattr$OFFSET, fieldValue);
+    }
+
+    /**
+     * {@snippet lang=c :
+     * int (*removexattr)(const char *, const char *)
+     * }
+     */
+    public static class removexattr {
+
+        removexattr() {
+            // Should not be called directly
+        }
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, MemorySegment _x1);
+        }
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(removexattr.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(removexattr.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
+    }
+
+    private static final AddressLayout removexattr$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("removexattr"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*removexattr)(const char *, const char *)
+     * }
+     */
+    public static final AddressLayout removexattr$layout() {
+        return removexattr$LAYOUT;
+    }
+
+    private static final long removexattr$OFFSET = 176;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*removexattr)(const char *, const char *)
+     * }
+     */
+    public static final long removexattr$offset() {
+        return removexattr$OFFSET;
+    }
+
+    /**
+     * Getter for field:
+     * {@snippet lang=c :
+     * int (*removexattr)(const char *, const char *)
+     * }
+     */
+    public static MemorySegment removexattr(MemorySegment struct) {
+        return struct.get(removexattr$LAYOUT, removexattr$OFFSET);
+    }
+
+    /**
+     * Setter for field:
+     * {@snippet lang=c :
+     * int (*removexattr)(const char *, const char *)
+     * }
+     */
+    public static void removexattr(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(removexattr$LAYOUT, removexattr$OFFSET, fieldValue);
+    }
+
+    /**
+     * {@snippet lang=c :
+     * int (*opendir)(const char *, struct fuse_file_info *)
+     * }
+     */
+    public static class opendir {
+
+        opendir() {
+            // Should not be called directly
+        }
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, MemorySegment _x1);
+        }
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(opendir.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(opendir.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
+    }
+
+    private static final AddressLayout opendir$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("opendir"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*opendir)(const char *, struct fuse_file_info *)
+     * }
+     */
+    public static final AddressLayout opendir$layout() {
+        return opendir$LAYOUT;
+    }
+
+    private static final long opendir$OFFSET = 184;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*opendir)(const char *, struct fuse_file_info *)
+     * }
+     */
+    public static final long opendir$offset() {
+        return opendir$OFFSET;
+    }
+
+    /**
+     * Getter for field:
+     * {@snippet lang=c :
+     * int (*opendir)(const char *, struct fuse_file_info *)
+     * }
+     */
+    public static MemorySegment opendir(MemorySegment struct) {
+        return struct.get(opendir$LAYOUT, opendir$OFFSET);
+    }
+
+    /**
+     * Setter for field:
+     * {@snippet lang=c :
+     * int (*opendir)(const char *, struct fuse_file_info *)
+     * }
+     */
+    public static void opendir(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(opendir$LAYOUT, opendir$OFFSET, fieldValue);
+    }
+
+    /**
+     * {@snippet lang=c :
+     * int (*readdir)(const char *, void *, fuse_fill_dir_t, off_t, struct fuse_file_info *, enum fuse_readdir_flags)
+     * }
+     */
+    public static class readdir {
+
+        readdir() {
+            // Should not be called directly
+        }
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, MemorySegment _x1, MemorySegment _x2, long _x3, MemorySegment _x4, int _x5);
+        }
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER,
+            fuse_h.C_LONG,
+            fuse_h.C_POINTER,
+            fuse_h.C_INT
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(readdir.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(readdir.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1, MemorySegment _x2, long _x3, MemorySegment _x4, int _x5) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2, _x3, _x4, _x5);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
+    }
+
+    private static final AddressLayout readdir$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("readdir"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*readdir)(const char *, void *, fuse_fill_dir_t, off_t, struct fuse_file_info *, enum fuse_readdir_flags)
+     * }
+     */
+    public static final AddressLayout readdir$layout() {
+        return readdir$LAYOUT;
+    }
+
+    private static final long readdir$OFFSET = 192;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*readdir)(const char *, void *, fuse_fill_dir_t, off_t, struct fuse_file_info *, enum fuse_readdir_flags)
+     * }
+     */
+    public static final long readdir$offset() {
+        return readdir$OFFSET;
+    }
+
+    /**
+     * Getter for field:
+     * {@snippet lang=c :
+     * int (*readdir)(const char *, void *, fuse_fill_dir_t, off_t, struct fuse_file_info *, enum fuse_readdir_flags)
+     * }
+     */
+    public static MemorySegment readdir(MemorySegment struct) {
+        return struct.get(readdir$LAYOUT, readdir$OFFSET);
+    }
+
+    /**
+     * Setter for field:
+     * {@snippet lang=c :
+     * int (*readdir)(const char *, void *, fuse_fill_dir_t, off_t, struct fuse_file_info *, enum fuse_readdir_flags)
+     * }
+     */
+    public static void readdir(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(readdir$LAYOUT, readdir$OFFSET, fieldValue);
+    }
+
+    /**
+     * {@snippet lang=c :
+     * int (*releasedir)(const char *, struct fuse_file_info *)
+     * }
+     */
+    public static class releasedir {
+
+        releasedir() {
+            // Should not be called directly
+        }
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, MemorySegment _x1);
+        }
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(releasedir.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(releasedir.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
+    }
+
+    private static final AddressLayout releasedir$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("releasedir"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*releasedir)(const char *, struct fuse_file_info *)
+     * }
+     */
+    public static final AddressLayout releasedir$layout() {
+        return releasedir$LAYOUT;
+    }
+
+    private static final long releasedir$OFFSET = 200;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*releasedir)(const char *, struct fuse_file_info *)
+     * }
+     */
+    public static final long releasedir$offset() {
+        return releasedir$OFFSET;
+    }
+
+    /**
+     * Getter for field:
+     * {@snippet lang=c :
+     * int (*releasedir)(const char *, struct fuse_file_info *)
+     * }
+     */
+    public static MemorySegment releasedir(MemorySegment struct) {
+        return struct.get(releasedir$LAYOUT, releasedir$OFFSET);
+    }
+
+    /**
+     * Setter for field:
+     * {@snippet lang=c :
+     * int (*releasedir)(const char *, struct fuse_file_info *)
+     * }
+     */
+    public static void releasedir(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(releasedir$LAYOUT, releasedir$OFFSET, fieldValue);
+    }
+
+    /**
+     * {@snippet lang=c :
+     * int (*fsyncdir)(const char *, int, struct fuse_file_info *)
+     * }
+     */
+    public static class fsyncdir {
+
+        fsyncdir() {
+            // Should not be called directly
+        }
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, int _x1, MemorySegment _x2);
+        }
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_INT,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(fsyncdir.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(fsyncdir.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, int _x1, MemorySegment _x2) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
+    }
+
+    private static final AddressLayout fsyncdir$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("fsyncdir"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*fsyncdir)(const char *, int, struct fuse_file_info *)
+     * }
+     */
+    public static final AddressLayout fsyncdir$layout() {
+        return fsyncdir$LAYOUT;
+    }
+
+    private static final long fsyncdir$OFFSET = 208;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*fsyncdir)(const char *, int, struct fuse_file_info *)
+     * }
+     */
+    public static final long fsyncdir$offset() {
+        return fsyncdir$OFFSET;
+    }
+
+    /**
+     * Getter for field:
+     * {@snippet lang=c :
+     * int (*fsyncdir)(const char *, int, struct fuse_file_info *)
+     * }
+     */
+    public static MemorySegment fsyncdir(MemorySegment struct) {
+        return struct.get(fsyncdir$LAYOUT, fsyncdir$OFFSET);
+    }
+
+    /**
+     * Setter for field:
+     * {@snippet lang=c :
+     * int (*fsyncdir)(const char *, int, struct fuse_file_info *)
+     * }
+     */
+    public static void fsyncdir(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(fsyncdir$LAYOUT, fsyncdir$OFFSET, fieldValue);
+    }
+
+    /**
+     * {@snippet lang=c :
+     * void *(*init)(struct fuse_conn_info *, struct fuse_config *)
+     * }
+     */
+    public static class init {
+
+        init() {
+            // Should not be called directly
+        }
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            MemorySegment apply(MemorySegment _x0, MemorySegment _x1);
+        }
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(init.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(init.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static MemorySegment invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1) {
+            try {
+                return (MemorySegment) DOWN$MH.invokeExact(funcPtr, _x0, _x1);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
+    }
+
+    private static final AddressLayout init$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("init"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * void *(*init)(struct fuse_conn_info *, struct fuse_config *)
+     * }
+     */
+    public static final AddressLayout init$layout() {
+        return init$LAYOUT;
+    }
+
+    private static final long init$OFFSET = 216;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * void *(*init)(struct fuse_conn_info *, struct fuse_config *)
+     * }
+     */
+    public static final long init$offset() {
+        return init$OFFSET;
+    }
+
+    /**
+     * Getter for field:
+     * {@snippet lang=c :
+     * void *(*init)(struct fuse_conn_info *, struct fuse_config *)
+     * }
+     */
+    public static MemorySegment init(MemorySegment struct) {
+        return struct.get(init$LAYOUT, init$OFFSET);
+    }
+
+    /**
+     * Setter for field:
+     * {@snippet lang=c :
+     * void *(*init)(struct fuse_conn_info *, struct fuse_config *)
+     * }
+     */
+    public static void init(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(init$LAYOUT, init$OFFSET, fieldValue);
+    }
+
+    /**
+     * {@snippet lang=c :
+     * void (*destroy)(void *)
+     * }
+     */
+    public static class destroy {
+
+        destroy() {
+            // Should not be called directly
+        }
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            void apply(MemorySegment _x0);
+        }
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.ofVoid(
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(destroy.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(destroy.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static void invoke(MemorySegment funcPtr,MemorySegment _x0) {
+            try {
+                 DOWN$MH.invokeExact(funcPtr, _x0);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
+    }
+
+    private static final AddressLayout destroy$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("destroy"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * void (*destroy)(void *)
+     * }
+     */
+    public static final AddressLayout destroy$layout() {
+        return destroy$LAYOUT;
+    }
+
+    private static final long destroy$OFFSET = 224;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * void (*destroy)(void *)
+     * }
+     */
+    public static final long destroy$offset() {
+        return destroy$OFFSET;
+    }
+
+    /**
+     * Getter for field:
+     * {@snippet lang=c :
+     * void (*destroy)(void *)
+     * }
+     */
+    public static MemorySegment destroy(MemorySegment struct) {
+        return struct.get(destroy$LAYOUT, destroy$OFFSET);
+    }
+
+    /**
+     * Setter for field:
+     * {@snippet lang=c :
+     * void (*destroy)(void *)
+     * }
+     */
+    public static void destroy(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(destroy$LAYOUT, destroy$OFFSET, fieldValue);
+    }
+
+    /**
+     * {@snippet lang=c :
+     * int (*access)(const char *, int)
+     * }
+     */
+    public static class access {
+
+        access() {
+            // Should not be called directly
+        }
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, int _x1);
+        }
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_INT
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(access.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(access.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, int _x1) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
+    }
+
+    private static final AddressLayout access$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("access"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*access)(const char *, int)
+     * }
+     */
+    public static final AddressLayout access$layout() {
+        return access$LAYOUT;
+    }
+
+    private static final long access$OFFSET = 232;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*access)(const char *, int)
+     * }
+     */
+    public static final long access$offset() {
+        return access$OFFSET;
+    }
+
+    /**
+     * Getter for field:
+     * {@snippet lang=c :
+     * int (*access)(const char *, int)
+     * }
+     */
+    public static MemorySegment access(MemorySegment struct) {
+        return struct.get(access$LAYOUT, access$OFFSET);
+    }
+
+    /**
+     * Setter for field:
+     * {@snippet lang=c :
+     * int (*access)(const char *, int)
+     * }
+     */
+    public static void access(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(access$LAYOUT, access$OFFSET, fieldValue);
+    }
+
+    /**
+     * {@snippet lang=c :
+     * int (*create)(const char *, mode_t, struct fuse_file_info *)
+     * }
+     */
+    public static class create {
+
+        create() {
+            // Should not be called directly
+        }
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, int _x1, MemorySegment _x2);
+        }
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_INT,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(create.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(create.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, int _x1, MemorySegment _x2) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
+    }
+
+    private static final AddressLayout create$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("create"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*create)(const char *, mode_t, struct fuse_file_info *)
+     * }
+     */
+    public static final AddressLayout create$layout() {
+        return create$LAYOUT;
+    }
+
+    private static final long create$OFFSET = 240;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*create)(const char *, mode_t, struct fuse_file_info *)
+     * }
+     */
+    public static final long create$offset() {
+        return create$OFFSET;
+    }
+
+    /**
+     * Getter for field:
+     * {@snippet lang=c :
+     * int (*create)(const char *, mode_t, struct fuse_file_info *)
+     * }
+     */
+    public static MemorySegment create(MemorySegment struct) {
+        return struct.get(create$LAYOUT, create$OFFSET);
+    }
+
+    /**
+     * Setter for field:
+     * {@snippet lang=c :
+     * int (*create)(const char *, mode_t, struct fuse_file_info *)
+     * }
+     */
+    public static void create(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(create$LAYOUT, create$OFFSET, fieldValue);
+    }
+
+    /**
+     * {@snippet lang=c :
+     * int (*lock)(const char *, struct fuse_file_info *, int, struct flock *)
+     * }
+     */
+    public static class lock {
+
+        lock() {
+            // Should not be called directly
+        }
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, MemorySegment _x1, int _x2, MemorySegment _x3);
+        }
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER,
+            fuse_h.C_INT,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(lock.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(lock.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1, int _x2, MemorySegment _x3) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2, _x3);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
+    }
+
+    private static final AddressLayout lock$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("lock"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*lock)(const char *, struct fuse_file_info *, int, struct flock *)
+     * }
+     */
+    public static final AddressLayout lock$layout() {
+        return lock$LAYOUT;
+    }
+
+    private static final long lock$OFFSET = 248;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*lock)(const char *, struct fuse_file_info *, int, struct flock *)
+     * }
+     */
+    public static final long lock$offset() {
+        return lock$OFFSET;
+    }
+
+    /**
+     * Getter for field:
+     * {@snippet lang=c :
+     * int (*lock)(const char *, struct fuse_file_info *, int, struct flock *)
+     * }
+     */
+    public static MemorySegment lock(MemorySegment struct) {
+        return struct.get(lock$LAYOUT, lock$OFFSET);
+    }
+
+    /**
+     * Setter for field:
+     * {@snippet lang=c :
+     * int (*lock)(const char *, struct fuse_file_info *, int, struct flock *)
+     * }
+     */
+    public static void lock(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(lock$LAYOUT, lock$OFFSET, fieldValue);
+    }
+
+    /**
+     * {@snippet lang=c :
+     * int (*utimens)(const char *, const struct timespec *, struct fuse_file_info *)
+     * }
+     */
+    public static class utimens {
+
+        utimens() {
+            // Should not be called directly
+        }
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, MemorySegment _x1, MemorySegment _x2);
+        }
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(utimens.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(utimens.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1, MemorySegment _x2) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
+    }
+
+    private static final AddressLayout utimens$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("utimens"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*utimens)(const char *, const struct timespec *, struct fuse_file_info *)
+     * }
+     */
+    public static final AddressLayout utimens$layout() {
+        return utimens$LAYOUT;
+    }
+
+    private static final long utimens$OFFSET = 256;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*utimens)(const char *, const struct timespec *, struct fuse_file_info *)
+     * }
+     */
+    public static final long utimens$offset() {
+        return utimens$OFFSET;
+    }
+
+    /**
+     * Getter for field:
+     * {@snippet lang=c :
+     * int (*utimens)(const char *, const struct timespec *, struct fuse_file_info *)
+     * }
+     */
+    public static MemorySegment utimens(MemorySegment struct) {
+        return struct.get(utimens$LAYOUT, utimens$OFFSET);
+    }
+
+    /**
+     * Setter for field:
+     * {@snippet lang=c :
+     * int (*utimens)(const char *, const struct timespec *, struct fuse_file_info *)
+     * }
+     */
+    public static void utimens(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(utimens$LAYOUT, utimens$OFFSET, fieldValue);
+    }
+
+    /**
+     * {@snippet lang=c :
+     * int (*bmap)(const char *, size_t, uint64_t *)
+     * }
+     */
+    public static class bmap {
+
+        bmap() {
+            // Should not be called directly
+        }
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, long _x1, MemorySegment _x2);
+        }
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_LONG,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(bmap.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(bmap.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, long _x1, MemorySegment _x2) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
+    }
+
+    private static final AddressLayout bmap$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("bmap"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*bmap)(const char *, size_t, uint64_t *)
+     * }
+     */
+    public static final AddressLayout bmap$layout() {
+        return bmap$LAYOUT;
+    }
+
+    private static final long bmap$OFFSET = 264;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*bmap)(const char *, size_t, uint64_t *)
+     * }
+     */
+    public static final long bmap$offset() {
+        return bmap$OFFSET;
+    }
+
+    /**
+     * Getter for field:
+     * {@snippet lang=c :
+     * int (*bmap)(const char *, size_t, uint64_t *)
+     * }
+     */
+    public static MemorySegment bmap(MemorySegment struct) {
+        return struct.get(bmap$LAYOUT, bmap$OFFSET);
+    }
+
+    /**
+     * Setter for field:
+     * {@snippet lang=c :
+     * int (*bmap)(const char *, size_t, uint64_t *)
+     * }
+     */
+    public static void bmap(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(bmap$LAYOUT, bmap$OFFSET, fieldValue);
+    }
+
+    /**
+     * {@snippet lang=c :
+     * int (*ioctl)(const char *, unsigned int, void *, struct fuse_file_info *, unsigned int, void *)
+     * }
+     */
+    public static class ioctl {
+
+        ioctl() {
+            // Should not be called directly
+        }
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, int _x1, MemorySegment _x2, MemorySegment _x3, int _x4, MemorySegment _x5);
+        }
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER,
+            fuse_h.C_INT,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(ioctl.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(ioctl.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, int _x1, MemorySegment _x2, MemorySegment _x3, int _x4, MemorySegment _x5) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2, _x3, _x4, _x5);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
+    }
+
+    private static final AddressLayout ioctl$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("ioctl"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*ioctl)(const char *, unsigned int, void *, struct fuse_file_info *, unsigned int, void *)
+     * }
+     */
+    public static final AddressLayout ioctl$layout() {
+        return ioctl$LAYOUT;
     }
+
+    private static final long ioctl$OFFSET = 272;
+
     /**
-     * {@snippet :
- * int (*fsyncdir)(char*,int,struct fuse_file_info*);
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*ioctl)(const char *, unsigned int, void *, struct fuse_file_info *, unsigned int, void *)
      * }
      */
-    public interface fsyncdir {
-
-        int apply(java.lang.foreign.MemorySegment _x0, int _x1, java.lang.foreign.MemorySegment _x2);
-        static MemorySegment allocate(fsyncdir fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$28.const$0, fi, constants$20.const$2, scope);
-        }
-        static fsyncdir ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, int __x1, java.lang.foreign.MemorySegment __x2) -> {
-                try {
-                    return (int)constants$20.const$4.invokeExact(symbol, __x0, __x1, __x2);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
-        }
+    public static final long ioctl$offset() {
+        return ioctl$OFFSET;
     }
 
-    public static VarHandle fsyncdir$VH() {
-        return constants$28.const$1;
-    }
     /**
      * Getter for field:
-     * {@snippet :
-     * int (*fsyncdir)(char*,int,struct fuse_file_info*);
+     * {@snippet lang=c :
+     * int (*ioctl)(const char *, unsigned int, void *, struct fuse_file_info *, unsigned int, void *)
      * }
      */
-    public static MemorySegment fsyncdir$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$28.const$1.get(seg);
+    public static MemorySegment ioctl(MemorySegment struct) {
+        return struct.get(ioctl$LAYOUT, ioctl$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int (*fsyncdir)(char*,int,struct fuse_file_info*);
+     * {@snippet lang=c :
+     * int (*ioctl)(const char *, unsigned int, void *, struct fuse_file_info *, unsigned int, void *)
      * }
      */
-    public static void fsyncdir$set(MemorySegment seg, MemorySegment x) {
-        constants$28.const$1.set(seg, x);
-    }
-    public static MemorySegment fsyncdir$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$28.const$1.get(seg.asSlice(index*sizeof()));
-    }
-    public static void fsyncdir$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$28.const$1.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static fsyncdir fsyncdir(MemorySegment segment, Arena scope) {
-        return fsyncdir.ofAddress(fsyncdir$get(segment), scope);
+    public static void ioctl(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(ioctl$LAYOUT, ioctl$OFFSET, fieldValue);
     }
+
     /**
-     * {@snippet :
- * void* (*init)(struct fuse_conn_info*,struct fuse_config*);
+     * {@snippet lang=c :
+     * int (*poll)(const char *, struct fuse_file_info *, struct fuse_pollhandle *, unsigned int *)
      * }
      */
-    public interface init {
+    public static class poll {
 
-        java.lang.foreign.MemorySegment apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1);
-        static MemorySegment allocate(init fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$28.const$3, fi, constants$28.const$2, scope);
+        poll() {
+            // Should not be called directly
         }
-        static init ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1) -> {
-                try {
-                    return (java.lang.foreign.MemorySegment)constants$28.const$4.invokeExact(symbol, __x0, __x1);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, MemorySegment _x1, MemorySegment _x2, MemorySegment _x3);
         }
-    }
 
-    public static VarHandle init$VH() {
-        return constants$28.const$5;
-    }
-    /**
-     * Getter for field:
-     * {@snippet :
-     * void* (*init)(struct fuse_conn_info*,struct fuse_config*);
-     * }
-     */
-    public static MemorySegment init$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$28.const$5.get(seg);
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(poll.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(poll.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1, MemorySegment _x2, MemorySegment _x3) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2, _x3);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
     }
+
+    private static final AddressLayout poll$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("poll"));
+
     /**
-     * Setter for field:
-     * {@snippet :
-     * void* (*init)(struct fuse_conn_info*,struct fuse_config*);
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*poll)(const char *, struct fuse_file_info *, struct fuse_pollhandle *, unsigned int *)
      * }
      */
-    public static void init$set(MemorySegment seg, MemorySegment x) {
-        constants$28.const$5.set(seg, x);
-    }
-    public static MemorySegment init$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$28.const$5.get(seg.asSlice(index*sizeof()));
-    }
-    public static void init$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$28.const$5.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static init init(MemorySegment segment, Arena scope) {
-        return init.ofAddress(init$get(segment), scope);
+    public static final AddressLayout poll$layout() {
+        return poll$LAYOUT;
     }
+
+    private static final long poll$OFFSET = 280;
+
     /**
-     * {@snippet :
- * void (*destroy)(void*);
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*poll)(const char *, struct fuse_file_info *, struct fuse_pollhandle *, unsigned int *)
      * }
      */
-    public interface destroy {
-
-        void apply(java.lang.foreign.MemorySegment _x0);
-        static MemorySegment allocate(destroy fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$29.const$0, fi, constants$5.const$0, scope);
-        }
-        static destroy ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0) -> {
-                try {
-                    constants$29.const$1.invokeExact(symbol, __x0);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
-        }
+    public static final long poll$offset() {
+        return poll$OFFSET;
     }
 
-    public static VarHandle destroy$VH() {
-        return constants$29.const$2;
-    }
     /**
      * Getter for field:
-     * {@snippet :
-     * void (*destroy)(void*);
+     * {@snippet lang=c :
+     * int (*poll)(const char *, struct fuse_file_info *, struct fuse_pollhandle *, unsigned int *)
      * }
      */
-    public static MemorySegment destroy$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$29.const$2.get(seg);
+    public static MemorySegment poll(MemorySegment struct) {
+        return struct.get(poll$LAYOUT, poll$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * void (*destroy)(void*);
+     * {@snippet lang=c :
+     * int (*poll)(const char *, struct fuse_file_info *, struct fuse_pollhandle *, unsigned int *)
      * }
      */
-    public static void destroy$set(MemorySegment seg, MemorySegment x) {
-        constants$29.const$2.set(seg, x);
-    }
-    public static MemorySegment destroy$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$29.const$2.get(seg.asSlice(index*sizeof()));
-    }
-    public static void destroy$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$29.const$2.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static destroy destroy(MemorySegment segment, Arena scope) {
-        return destroy.ofAddress(destroy$get(segment), scope);
+    public static void poll(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(poll$LAYOUT, poll$OFFSET, fieldValue);
     }
+
     /**
-     * {@snippet :
- * int (*access)(char*,int);
+     * {@snippet lang=c :
+     * int (*write_buf)(const char *, struct fuse_bufvec *, off_t, struct fuse_file_info *)
      * }
      */
-    public interface access {
+    public static class write_buf {
 
-        int apply(java.lang.foreign.MemorySegment _x0, int _x1);
-        static MemorySegment allocate(access fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$29.const$3, fi, constants$17.const$0, scope);
+        write_buf() {
+            // Should not be called directly
         }
-        static access ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, int __x1) -> {
-                try {
-                    return (int)constants$17.const$2.invokeExact(symbol, __x0, __x1);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, MemorySegment _x1, long _x2, MemorySegment _x3);
         }
-    }
 
-    public static VarHandle access$VH() {
-        return constants$29.const$4;
-    }
-    /**
-     * Getter for field:
-     * {@snippet :
-     * int (*access)(char*,int);
-     * }
-     */
-    public static MemorySegment access$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$29.const$4.get(seg);
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER,
+            fuse_h.C_LONG,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(write_buf.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(write_buf.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1, long _x2, MemorySegment _x3) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2, _x3);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
     }
+
+    private static final AddressLayout write_buf$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("write_buf"));
+
     /**
-     * Setter for field:
-     * {@snippet :
-     * int (*access)(char*,int);
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*write_buf)(const char *, struct fuse_bufvec *, off_t, struct fuse_file_info *)
      * }
      */
-    public static void access$set(MemorySegment seg, MemorySegment x) {
-        constants$29.const$4.set(seg, x);
-    }
-    public static MemorySegment access$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$29.const$4.get(seg.asSlice(index*sizeof()));
-    }
-    public static void access$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$29.const$4.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static access access(MemorySegment segment, Arena scope) {
-        return access.ofAddress(access$get(segment), scope);
+    public static final AddressLayout write_buf$layout() {
+        return write_buf$LAYOUT;
     }
+
+    private static final long write_buf$OFFSET = 288;
+
     /**
-     * {@snippet :
- * int (*create)(char*,unsigned int,struct fuse_file_info*);
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*write_buf)(const char *, struct fuse_bufvec *, off_t, struct fuse_file_info *)
      * }
      */
-    public interface create {
-
-        int apply(java.lang.foreign.MemorySegment _x0, int _x1, java.lang.foreign.MemorySegment _x2);
-        static MemorySegment allocate(create fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$29.const$5, fi, constants$20.const$2, scope);
-        }
-        static create ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, int __x1, java.lang.foreign.MemorySegment __x2) -> {
-                try {
-                    return (int)constants$20.const$4.invokeExact(symbol, __x0, __x1, __x2);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
-        }
+    public static final long write_buf$offset() {
+        return write_buf$OFFSET;
     }
 
-    public static VarHandle create$VH() {
-        return constants$30.const$0;
-    }
     /**
      * Getter for field:
-     * {@snippet :
-     * int (*create)(char*,unsigned int,struct fuse_file_info*);
+     * {@snippet lang=c :
+     * int (*write_buf)(const char *, struct fuse_bufvec *, off_t, struct fuse_file_info *)
      * }
      */
-    public static MemorySegment create$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$30.const$0.get(seg);
+    public static MemorySegment write_buf(MemorySegment struct) {
+        return struct.get(write_buf$LAYOUT, write_buf$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int (*create)(char*,unsigned int,struct fuse_file_info*);
+     * {@snippet lang=c :
+     * int (*write_buf)(const char *, struct fuse_bufvec *, off_t, struct fuse_file_info *)
      * }
      */
-    public static void create$set(MemorySegment seg, MemorySegment x) {
-        constants$30.const$0.set(seg, x);
-    }
-    public static MemorySegment create$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$30.const$0.get(seg.asSlice(index*sizeof()));
-    }
-    public static void create$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$30.const$0.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static create create(MemorySegment segment, Arena scope) {
-        return create.ofAddress(create$get(segment), scope);
+    public static void write_buf(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(write_buf$LAYOUT, write_buf$OFFSET, fieldValue);
     }
+
     /**
-     * {@snippet :
- * int (*lock)(char*,struct fuse_file_info*,int,struct flock*);
+     * {@snippet lang=c :
+     * int (*read_buf)(const char *, struct fuse_bufvec **, size_t, off_t, struct fuse_file_info *)
      * }
      */
-    public interface lock {
+    public static class read_buf {
 
-        int apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1, int _x2, java.lang.foreign.MemorySegment _x3);
-        static MemorySegment allocate(lock fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$30.const$2, fi, constants$30.const$1, scope);
+        read_buf() {
+            // Should not be called directly
         }
-        static lock ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1, int __x2, java.lang.foreign.MemorySegment __x3) -> {
-                try {
-                    return (int)constants$30.const$3.invokeExact(symbol, __x0, __x1, __x2, __x3);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, MemorySegment _x1, long _x2, long _x3, MemorySegment _x4);
         }
-    }
 
-    public static VarHandle lock$VH() {
-        return constants$30.const$4;
-    }
-    /**
-     * Getter for field:
-     * {@snippet :
-     * int (*lock)(char*,struct fuse_file_info*,int,struct flock*);
-     * }
-     */
-    public static MemorySegment lock$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$30.const$4.get(seg);
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER,
+            fuse_h.C_LONG,
+            fuse_h.C_LONG,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(read_buf.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(read_buf.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1, long _x2, long _x3, MemorySegment _x4) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2, _x3, _x4);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
     }
+
+    private static final AddressLayout read_buf$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("read_buf"));
+
     /**
-     * Setter for field:
-     * {@snippet :
-     * int (*lock)(char*,struct fuse_file_info*,int,struct flock*);
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*read_buf)(const char *, struct fuse_bufvec **, size_t, off_t, struct fuse_file_info *)
      * }
      */
-    public static void lock$set(MemorySegment seg, MemorySegment x) {
-        constants$30.const$4.set(seg, x);
-    }
-    public static MemorySegment lock$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$30.const$4.get(seg.asSlice(index*sizeof()));
-    }
-    public static void lock$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$30.const$4.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static lock lock(MemorySegment segment, Arena scope) {
-        return lock.ofAddress(lock$get(segment), scope);
+    public static final AddressLayout read_buf$layout() {
+        return read_buf$LAYOUT;
     }
+
+    private static final long read_buf$OFFSET = 296;
+
     /**
-     * {@snippet :
- * int (*utimens)(char*,struct timespec*,struct fuse_file_info*);
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*read_buf)(const char *, struct fuse_bufvec **, size_t, off_t, struct fuse_file_info *)
      * }
      */
-    public interface utimens {
-
-        int apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1, java.lang.foreign.MemorySegment _x2);
-        static MemorySegment allocate(utimens fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$30.const$5, fi, constants$15.const$0, scope);
-        }
-        static utimens ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1, java.lang.foreign.MemorySegment __x2) -> {
-                try {
-                    return (int)constants$15.const$2.invokeExact(symbol, __x0, __x1, __x2);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
-        }
+    public static final long read_buf$offset() {
+        return read_buf$OFFSET;
     }
 
-    public static VarHandle utimens$VH() {
-        return constants$31.const$0;
-    }
     /**
      * Getter for field:
-     * {@snippet :
-     * int (*utimens)(char*,struct timespec*,struct fuse_file_info*);
+     * {@snippet lang=c :
+     * int (*read_buf)(const char *, struct fuse_bufvec **, size_t, off_t, struct fuse_file_info *)
      * }
      */
-    public static MemorySegment utimens$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$31.const$0.get(seg);
+    public static MemorySegment read_buf(MemorySegment struct) {
+        return struct.get(read_buf$LAYOUT, read_buf$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int (*utimens)(char*,struct timespec*,struct fuse_file_info*);
+     * {@snippet lang=c :
+     * int (*read_buf)(const char *, struct fuse_bufvec **, size_t, off_t, struct fuse_file_info *)
      * }
      */
-    public static void utimens$set(MemorySegment seg, MemorySegment x) {
-        constants$31.const$0.set(seg, x);
-    }
-    public static MemorySegment utimens$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$31.const$0.get(seg.asSlice(index*sizeof()));
-    }
-    public static void utimens$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$31.const$0.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static utimens utimens(MemorySegment segment, Arena scope) {
-        return utimens.ofAddress(utimens$get(segment), scope);
+    public static void read_buf(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(read_buf$LAYOUT, read_buf$OFFSET, fieldValue);
     }
+
     /**
-     * {@snippet :
- * int (*bmap)(char*,unsigned long,unsigned long*);
+     * {@snippet lang=c :
+     * int (*flock)(const char *, struct fuse_file_info *, int)
      * }
      */
-    public interface bmap {
+    public static class flock {
 
-        int apply(java.lang.foreign.MemorySegment _x0, long _x1, java.lang.foreign.MemorySegment _x2);
-        static MemorySegment allocate(bmap fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$31.const$1, fi, constants$21.const$4, scope);
+        flock() {
+            // Should not be called directly
         }
-        static bmap ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, long __x1, java.lang.foreign.MemorySegment __x2) -> {
-                try {
-                    return (int)constants$22.const$0.invokeExact(symbol, __x0, __x1, __x2);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, MemorySegment _x1, int _x2);
         }
-    }
 
-    public static VarHandle bmap$VH() {
-        return constants$31.const$2;
-    }
-    /**
-     * Getter for field:
-     * {@snippet :
-     * int (*bmap)(char*,unsigned long,unsigned long*);
-     * }
-     */
-    public static MemorySegment bmap$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$31.const$2.get(seg);
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER,
+            fuse_h.C_INT
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(flock.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(flock.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1, int _x2) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
     }
+
+    private static final AddressLayout flock$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("flock"));
+
     /**
-     * Setter for field:
-     * {@snippet :
-     * int (*bmap)(char*,unsigned long,unsigned long*);
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*flock)(const char *, struct fuse_file_info *, int)
      * }
      */
-    public static void bmap$set(MemorySegment seg, MemorySegment x) {
-        constants$31.const$2.set(seg, x);
-    }
-    public static MemorySegment bmap$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$31.const$2.get(seg.asSlice(index*sizeof()));
-    }
-    public static void bmap$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$31.const$2.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static bmap bmap(MemorySegment segment, Arena scope) {
-        return bmap.ofAddress(bmap$get(segment), scope);
+    public static final AddressLayout flock$layout() {
+        return flock$LAYOUT;
     }
+
+    private static final long flock$OFFSET = 304;
+
     /**
-     * {@snippet :
- * int (*ioctl)(char*,unsigned int,void*,struct fuse_file_info*,unsigned int,void*);
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*flock)(const char *, struct fuse_file_info *, int)
      * }
      */
-    public interface ioctl {
-
-        int apply(java.lang.foreign.MemorySegment _x0, int _x1, java.lang.foreign.MemorySegment _x2, java.lang.foreign.MemorySegment _x3, int _x4, java.lang.foreign.MemorySegment _x5);
-        static MemorySegment allocate(ioctl fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$31.const$4, fi, constants$31.const$3, scope);
-        }
-        static ioctl ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, int __x1, java.lang.foreign.MemorySegment __x2, java.lang.foreign.MemorySegment __x3, int __x4, java.lang.foreign.MemorySegment __x5) -> {
-                try {
-                    return (int)constants$31.const$5.invokeExact(symbol, __x0, __x1, __x2, __x3, __x4, __x5);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
-        }
+    public static final long flock$offset() {
+        return flock$OFFSET;
     }
 
-    public static VarHandle ioctl$VH() {
-        return constants$32.const$0;
-    }
     /**
      * Getter for field:
-     * {@snippet :
-     * int (*ioctl)(char*,unsigned int,void*,struct fuse_file_info*,unsigned int,void*);
+     * {@snippet lang=c :
+     * int (*flock)(const char *, struct fuse_file_info *, int)
      * }
      */
-    public static MemorySegment ioctl$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$32.const$0.get(seg);
+    public static MemorySegment flock(MemorySegment struct) {
+        return struct.get(flock$LAYOUT, flock$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int (*ioctl)(char*,unsigned int,void*,struct fuse_file_info*,unsigned int,void*);
+     * {@snippet lang=c :
+     * int (*flock)(const char *, struct fuse_file_info *, int)
      * }
      */
-    public static void ioctl$set(MemorySegment seg, MemorySegment x) {
-        constants$32.const$0.set(seg, x);
-    }
-    public static MemorySegment ioctl$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$32.const$0.get(seg.asSlice(index*sizeof()));
-    }
-    public static void ioctl$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$32.const$0.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static ioctl ioctl(MemorySegment segment, Arena scope) {
-        return ioctl.ofAddress(ioctl$get(segment), scope);
+    public static void flock(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(flock$LAYOUT, flock$OFFSET, fieldValue);
     }
+
     /**
-     * {@snippet :
- * int (*poll)(char*,struct fuse_file_info*,struct fuse_pollhandle*,unsigned int*);
+     * {@snippet lang=c :
+     * int (*fallocate)(const char *, int, off_t, off_t, struct fuse_file_info *)
      * }
      */
-    public interface poll {
+    public static class fallocate {
 
-        int apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1, java.lang.foreign.MemorySegment _x2, java.lang.foreign.MemorySegment _x3);
-        static MemorySegment allocate(poll fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$32.const$2, fi, constants$32.const$1, scope);
+        fallocate() {
+            // Should not be called directly
         }
-        static poll ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1, java.lang.foreign.MemorySegment __x2, java.lang.foreign.MemorySegment __x3) -> {
-                try {
-                    return (int)constants$32.const$3.invokeExact(symbol, __x0, __x1, __x2, __x3);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, int _x1, long _x2, long _x3, MemorySegment _x4);
         }
-    }
 
-    public static VarHandle poll$VH() {
-        return constants$32.const$4;
-    }
-    /**
-     * Getter for field:
-     * {@snippet :
-     * int (*poll)(char*,struct fuse_file_info*,struct fuse_pollhandle*,unsigned int*);
-     * }
-     */
-    public static MemorySegment poll$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$32.const$4.get(seg);
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_INT,
+            fuse_h.C_LONG,
+            fuse_h.C_LONG,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(fallocate.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(fallocate.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, int _x1, long _x2, long _x3, MemorySegment _x4) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2, _x3, _x4);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
     }
+
+    private static final AddressLayout fallocate$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("fallocate"));
+
     /**
-     * Setter for field:
-     * {@snippet :
-     * int (*poll)(char*,struct fuse_file_info*,struct fuse_pollhandle*,unsigned int*);
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*fallocate)(const char *, int, off_t, off_t, struct fuse_file_info *)
      * }
      */
-    public static void poll$set(MemorySegment seg, MemorySegment x) {
-        constants$32.const$4.set(seg, x);
-    }
-    public static MemorySegment poll$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$32.const$4.get(seg.asSlice(index*sizeof()));
-    }
-    public static void poll$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$32.const$4.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static poll poll(MemorySegment segment, Arena scope) {
-        return poll.ofAddress(poll$get(segment), scope);
+    public static final AddressLayout fallocate$layout() {
+        return fallocate$LAYOUT;
     }
+
+    private static final long fallocate$OFFSET = 312;
+
     /**
-     * {@snippet :
- * int (*write_buf)(char*,struct fuse_bufvec*,long,struct fuse_file_info*);
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*fallocate)(const char *, int, off_t, off_t, struct fuse_file_info *)
      * }
      */
-    public interface write_buf {
-
-        int apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1, long _x2, java.lang.foreign.MemorySegment _x3);
-        static MemorySegment allocate(write_buf fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$33.const$0, fi, constants$32.const$5, scope);
-        }
-        static write_buf ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1, long __x2, java.lang.foreign.MemorySegment __x3) -> {
-                try {
-                    return (int)constants$33.const$1.invokeExact(symbol, __x0, __x1, __x2, __x3);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
-        }
+    public static final long fallocate$offset() {
+        return fallocate$OFFSET;
     }
 
-    public static VarHandle write_buf$VH() {
-        return constants$33.const$2;
-    }
     /**
      * Getter for field:
-     * {@snippet :
-     * int (*write_buf)(char*,struct fuse_bufvec*,long,struct fuse_file_info*);
+     * {@snippet lang=c :
+     * int (*fallocate)(const char *, int, off_t, off_t, struct fuse_file_info *)
      * }
      */
-    public static MemorySegment write_buf$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$33.const$2.get(seg);
+    public static MemorySegment fallocate(MemorySegment struct) {
+        return struct.get(fallocate$LAYOUT, fallocate$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int (*write_buf)(char*,struct fuse_bufvec*,long,struct fuse_file_info*);
+     * {@snippet lang=c :
+     * int (*fallocate)(const char *, int, off_t, off_t, struct fuse_file_info *)
      * }
      */
-    public static void write_buf$set(MemorySegment seg, MemorySegment x) {
-        constants$33.const$2.set(seg, x);
-    }
-    public static MemorySegment write_buf$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$33.const$2.get(seg.asSlice(index*sizeof()));
-    }
-    public static void write_buf$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$33.const$2.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static write_buf write_buf(MemorySegment segment, Arena scope) {
-        return write_buf.ofAddress(write_buf$get(segment), scope);
+    public static void fallocate(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(fallocate$LAYOUT, fallocate$OFFSET, fieldValue);
     }
+
     /**
-     * {@snippet :
- * int (*read_buf)(char*,struct fuse_bufvec**,unsigned long,long,struct fuse_file_info*);
+     * {@snippet lang=c :
+     * ssize_t (*copy_file_range)(const char *, struct fuse_file_info *, off_t, const char *, struct fuse_file_info *, off_t, size_t, int)
      * }
      */
-    public interface read_buf {
+    public static class copy_file_range {
 
-        int apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1, long _x2, long _x3, java.lang.foreign.MemorySegment _x4);
-        static MemorySegment allocate(read_buf fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$33.const$3, fi, constants$22.const$4, scope);
+        copy_file_range() {
+            // Should not be called directly
         }
-        static read_buf ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1, long __x2, long __x3, java.lang.foreign.MemorySegment __x4) -> {
-                try {
-                    return (int)constants$23.const$0.invokeExact(symbol, __x0, __x1, __x2, __x3, __x4);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            long apply(MemorySegment _x0, MemorySegment _x1, long _x2, MemorySegment _x3, MemorySegment _x4, long _x5, long _x6, int _x7);
         }
-    }
 
-    public static VarHandle read_buf$VH() {
-        return constants$33.const$4;
-    }
-    /**
-     * Getter for field:
-     * {@snippet :
-     * int (*read_buf)(char*,struct fuse_bufvec**,unsigned long,long,struct fuse_file_info*);
-     * }
-     */
-    public static MemorySegment read_buf$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$33.const$4.get(seg);
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_LONG,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER,
+            fuse_h.C_LONG,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER,
+            fuse_h.C_LONG,
+            fuse_h.C_LONG,
+            fuse_h.C_INT
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(copy_file_range.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(copy_file_range.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static long invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1, long _x2, MemorySegment _x3, MemorySegment _x4, long _x5, long _x6, int _x7) {
+            try {
+                return (long) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2, _x3, _x4, _x5, _x6, _x7);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
     }
+
+    private static final AddressLayout copy_file_range$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("copy_file_range"));
+
     /**
-     * Setter for field:
-     * {@snippet :
-     * int (*read_buf)(char*,struct fuse_bufvec**,unsigned long,long,struct fuse_file_info*);
+     * Layout for field:
+     * {@snippet lang=c :
+     * ssize_t (*copy_file_range)(const char *, struct fuse_file_info *, off_t, const char *, struct fuse_file_info *, off_t, size_t, int)
      * }
      */
-    public static void read_buf$set(MemorySegment seg, MemorySegment x) {
-        constants$33.const$4.set(seg, x);
-    }
-    public static MemorySegment read_buf$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$33.const$4.get(seg.asSlice(index*sizeof()));
-    }
-    public static void read_buf$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$33.const$4.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static read_buf read_buf(MemorySegment segment, Arena scope) {
-        return read_buf.ofAddress(read_buf$get(segment), scope);
+    public static final AddressLayout copy_file_range$layout() {
+        return copy_file_range$LAYOUT;
     }
+
+    private static final long copy_file_range$OFFSET = 320;
+
     /**
-     * {@snippet :
- * int (*flock)(char*,struct fuse_file_info*,int);
+     * Offset for field:
+     * {@snippet lang=c :
+     * ssize_t (*copy_file_range)(const char *, struct fuse_file_info *, off_t, const char *, struct fuse_file_info *, off_t, size_t, int)
      * }
      */
-    public interface flock {
-
-        int apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1, int _x2);
-        static MemorySegment allocate(flock fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$33.const$5, fi, constants$19.const$2, scope);
-        }
-        static flock ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1, int __x2) -> {
-                try {
-                    return (int)constants$19.const$4.invokeExact(symbol, __x0, __x1, __x2);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
-        }
+    public static final long copy_file_range$offset() {
+        return copy_file_range$OFFSET;
     }
 
-    public static VarHandle flock$VH() {
-        return constants$34.const$0;
-    }
     /**
      * Getter for field:
-     * {@snippet :
-     * int (*flock)(char*,struct fuse_file_info*,int);
+     * {@snippet lang=c :
+     * ssize_t (*copy_file_range)(const char *, struct fuse_file_info *, off_t, const char *, struct fuse_file_info *, off_t, size_t, int)
      * }
      */
-    public static MemorySegment flock$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$34.const$0.get(seg);
+    public static MemorySegment copy_file_range(MemorySegment struct) {
+        return struct.get(copy_file_range$LAYOUT, copy_file_range$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int (*flock)(char*,struct fuse_file_info*,int);
+     * {@snippet lang=c :
+     * ssize_t (*copy_file_range)(const char *, struct fuse_file_info *, off_t, const char *, struct fuse_file_info *, off_t, size_t, int)
      * }
      */
-    public static void flock$set(MemorySegment seg, MemorySegment x) {
-        constants$34.const$0.set(seg, x);
-    }
-    public static MemorySegment flock$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$34.const$0.get(seg.asSlice(index*sizeof()));
-    }
-    public static void flock$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$34.const$0.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static flock flock(MemorySegment segment, Arena scope) {
-        return flock.ofAddress(flock$get(segment), scope);
+    public static void copy_file_range(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(copy_file_range$LAYOUT, copy_file_range$OFFSET, fieldValue);
     }
+
     /**
-     * {@snippet :
- * int (*fallocate)(char*,int,long,long,struct fuse_file_info*);
+     * {@snippet lang=c :
+     * off_t (*lseek)(const char *, off_t, int, struct fuse_file_info *)
      * }
      */
-    public interface fallocate {
+    public static class lseek {
 
-        int apply(java.lang.foreign.MemorySegment _x0, int _x1, long _x2, long _x3, java.lang.foreign.MemorySegment _x4);
-        static MemorySegment allocate(fallocate fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$34.const$2, fi, constants$34.const$1, scope);
+        lseek() {
+            // Should not be called directly
         }
-        static fallocate ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, int __x1, long __x2, long __x3, java.lang.foreign.MemorySegment __x4) -> {
-                try {
-                    return (int)constants$34.const$3.invokeExact(symbol, __x0, __x1, __x2, __x3, __x4);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            long apply(MemorySegment _x0, long _x1, int _x2, MemorySegment _x3);
         }
-    }
 
-    public static VarHandle fallocate$VH() {
-        return constants$34.const$4;
-    }
-    /**
-     * Getter for field:
-     * {@snippet :
-     * int (*fallocate)(char*,int,long,long,struct fuse_file_info*);
-     * }
-     */
-    public static MemorySegment fallocate$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$34.const$4.get(seg);
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_LONG,
+            fuse_h.C_POINTER,
+            fuse_h.C_LONG,
+            fuse_h.C_INT,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(lseek.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(lseek.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static long invoke(MemorySegment funcPtr,MemorySegment _x0, long _x1, int _x2, MemorySegment _x3) {
+            try {
+                return (long) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2, _x3);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
     }
+
+    private static final AddressLayout lseek$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("lseek"));
+
     /**
-     * Setter for field:
-     * {@snippet :
-     * int (*fallocate)(char*,int,long,long,struct fuse_file_info*);
+     * Layout for field:
+     * {@snippet lang=c :
+     * off_t (*lseek)(const char *, off_t, int, struct fuse_file_info *)
      * }
      */
-    public static void fallocate$set(MemorySegment seg, MemorySegment x) {
-        constants$34.const$4.set(seg, x);
-    }
-    public static MemorySegment fallocate$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$34.const$4.get(seg.asSlice(index*sizeof()));
-    }
-    public static void fallocate$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$34.const$4.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static fallocate fallocate(MemorySegment segment, Arena scope) {
-        return fallocate.ofAddress(fallocate$get(segment), scope);
+    public static final AddressLayout lseek$layout() {
+        return lseek$LAYOUT;
     }
+
+    private static final long lseek$OFFSET = 328;
+
     /**
-     * {@snippet :
- * long (*copy_file_range)(char*,struct fuse_file_info*,long,char*,struct fuse_file_info*,long,unsigned long,int);
+     * Offset for field:
+     * {@snippet lang=c :
+     * off_t (*lseek)(const char *, off_t, int, struct fuse_file_info *)
      * }
      */
-    public interface copy_file_range {
-
-        long apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1, long _x2, java.lang.foreign.MemorySegment _x3, java.lang.foreign.MemorySegment _x4, long _x5, long _x6, int _x7);
-        static MemorySegment allocate(copy_file_range fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$35.const$0, fi, constants$34.const$5, scope);
-        }
-        static copy_file_range ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1, long __x2, java.lang.foreign.MemorySegment __x3, java.lang.foreign.MemorySegment __x4, long __x5, long __x6, int __x7) -> {
-                try {
-                    return (long)constants$35.const$1.invokeExact(symbol, __x0, __x1, __x2, __x3, __x4, __x5, __x6, __x7);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
-        }
+    public static final long lseek$offset() {
+        return lseek$OFFSET;
     }
 
-    public static VarHandle copy_file_range$VH() {
-        return constants$35.const$2;
-    }
     /**
      * Getter for field:
-     * {@snippet :
-     * long (*copy_file_range)(char*,struct fuse_file_info*,long,char*,struct fuse_file_info*,long,unsigned long,int);
+     * {@snippet lang=c :
+     * off_t (*lseek)(const char *, off_t, int, struct fuse_file_info *)
      * }
      */
-    public static MemorySegment copy_file_range$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$35.const$2.get(seg);
+    public static MemorySegment lseek(MemorySegment struct) {
+        return struct.get(lseek$LAYOUT, lseek$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * long (*copy_file_range)(char*,struct fuse_file_info*,long,char*,struct fuse_file_info*,long,unsigned long,int);
+     * {@snippet lang=c :
+     * off_t (*lseek)(const char *, off_t, int, struct fuse_file_info *)
      * }
      */
-    public static void copy_file_range$set(MemorySegment seg, MemorySegment x) {
-        constants$35.const$2.set(seg, x);
+    public static void lseek(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(lseek$LAYOUT, lseek$OFFSET, fieldValue);
     }
-    public static MemorySegment copy_file_range$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$35.const$2.get(seg.asSlice(index*sizeof()));
-    }
-    public static void copy_file_range$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$35.const$2.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static copy_file_range copy_file_range(MemorySegment segment, Arena scope) {
-        return copy_file_range.ofAddress(copy_file_range$get(segment), scope);
+
+    /**
+     * Obtains a slice of {@code arrayParam} which selects the array element at {@code index}.
+     * The returned segment has address {@code arrayParam.address() + index * layout().byteSize()}
+     */
+    public static MemorySegment asSlice(MemorySegment array, long index) {
+        return array.asSlice(layout().byteSize() * index);
     }
+
     /**
-     * {@snippet :
- * long (*lseek)(char*,long,int,struct fuse_file_info*);
-     * }
+     * The size (in bytes) of this struct
      */
-    public interface lseek {
+    public static long sizeof() { return layout().byteSize(); }
 
-        long apply(java.lang.foreign.MemorySegment _x0, long _x1, int _x2, java.lang.foreign.MemorySegment _x3);
-        static MemorySegment allocate(lseek fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$35.const$4, fi, constants$35.const$3, scope);
-        }
-        static lseek ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, long __x1, int __x2, java.lang.foreign.MemorySegment __x3) -> {
-                try {
-                    return (long)constants$35.const$5.invokeExact(symbol, __x0, __x1, __x2, __x3);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
-        }
+    /**
+     * Allocate a segment of size {@code layout().byteSize()} using {@code allocator}
+     */
+    public static MemorySegment allocate(SegmentAllocator allocator) {
+        return allocator.allocate(layout());
     }
 
-    public static VarHandle lseek$VH() {
-        return constants$36.const$0;
-    }
     /**
-     * Getter for field:
-     * {@snippet :
-     * long (*lseek)(char*,long,int,struct fuse_file_info*);
-     * }
+     * Allocate an array of size {@code elementCount} using {@code allocator}.
+     * The returned segment has size {@code elementCount * layout().byteSize()}.
      */
-    public static MemorySegment lseek$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$36.const$0.get(seg);
+    public static MemorySegment allocateArray(long elementCount, SegmentAllocator allocator) {
+        return allocator.allocate(MemoryLayout.sequenceLayout(elementCount, layout()));
     }
+
     /**
-     * Setter for field:
-     * {@snippet :
-     * long (*lseek)(char*,long,int,struct fuse_file_info*);
-     * }
+     * Reinterprets {@code addr} using target {@code arena} and {@code cleanupAction) (if any).
+     * The returned segment has size {@code layout().byteSize()}
      */
-    public static void lseek$set(MemorySegment seg, MemorySegment x) {
-        constants$36.const$0.set(seg, x);
-    }
-    public static MemorySegment lseek$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$36.const$0.get(seg.asSlice(index*sizeof()));
-    }
-    public static void lseek$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$36.const$0.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static lseek lseek(MemorySegment segment, Arena scope) {
-        return lseek.ofAddress(lseek$get(segment), scope);
+    public static MemorySegment reinterpret(MemorySegment addr, Arena arena, Consumer<MemorySegment> cleanup) {
+        return reinterpret(addr, 1, arena, cleanup);
     }
-    public static long sizeof() { return $LAYOUT().byteSize(); }
-    public static MemorySegment allocate(SegmentAllocator allocator) { return allocator.allocate($LAYOUT()); }
-    public static MemorySegment allocateArray(long len, SegmentAllocator allocator) {
-        return allocator.allocate(MemoryLayout.sequenceLayout(len, $LAYOUT()));
+
+    /**
+     * Reinterprets {@code addr} using target {@code arena} and {@code cleanupAction) (if any).
+     * The returned segment has size {@code elementCount * layout().byteSize()}
+     */
+    public static MemorySegment reinterpret(MemorySegment addr, long elementCount, Arena arena, Consumer<MemorySegment> cleanup) {
+        return addr.reinterpret(layout().byteSize() * elementCount, arena, cleanup);
     }
-    public static MemorySegment ofAddress(MemorySegment addr, Arena scope) { return RuntimeHelper.asArray(addr, $LAYOUT(), 1, scope); }
 }
 
-
diff --git a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/stat.java b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/stat.java
index 73ab0361..34a32ccc 100644
--- a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/stat.java
+++ b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/stat.java
@@ -2,380 +2,849 @@
 
 package org.cryptomator.jfuse.linux.aarch64.extr.fuse3;
 
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
+import java.lang.invoke.*;
 import java.lang.foreign.*;
+import java.nio.ByteOrder;
+import java.util.*;
+import java.util.function.*;
+import java.util.stream.*;
+
 import static java.lang.foreign.ValueLayout.*;
+import static java.lang.foreign.MemoryLayout.PathElement.*;
+
 /**
- * {@snippet :
+ * {@snippet lang=c :
  * struct stat {
- *     unsigned long st_dev;
- *     unsigned long st_ino;
- *     unsigned int st_mode;
- *     unsigned int st_nlink;
- *     unsigned int st_uid;
- *     unsigned int st_gid;
- *     unsigned long st_rdev;
- *     unsigned long __pad1;
- *     long st_size;
- *     int st_blksize;
+ *     __dev_t st_dev;
+ *     __ino64_t st_ino;
+ *     __mode_t st_mode;
+ *     __nlink_t st_nlink;
+ *     __uid_t st_uid;
+ *     __gid_t st_gid;
+ *     __dev_t st_rdev;
+ *     __dev_t __pad1;
+ *     __off64_t st_size;
+ *     __blksize_t st_blksize;
  *     int __pad2;
- *     long st_blocks;
+ *     __blkcnt64_t st_blocks;
  *     struct timespec st_atim;
  *     struct timespec st_mtim;
  *     struct timespec st_ctim;
  *     int __glibc_reserved[2];
- * };
+ * }
  * }
  */
 public class stat {
 
-    public static MemoryLayout $LAYOUT() {
-        return constants$5.const$5;
+    stat() {
+        // Should not be called directly
+    }
+
+    private static final GroupLayout $LAYOUT = MemoryLayout.structLayout(
+        fuse_h.C_LONG.withName("st_dev"),
+        fuse_h.C_LONG.withName("st_ino"),
+        fuse_h.C_INT.withName("st_mode"),
+        fuse_h.C_INT.withName("st_nlink"),
+        fuse_h.C_INT.withName("st_uid"),
+        fuse_h.C_INT.withName("st_gid"),
+        fuse_h.C_LONG.withName("st_rdev"),
+        fuse_h.C_LONG.withName("__pad1"),
+        fuse_h.C_LONG.withName("st_size"),
+        fuse_h.C_INT.withName("st_blksize"),
+        fuse_h.C_INT.withName("__pad2"),
+        fuse_h.C_LONG.withName("st_blocks"),
+        timespec.layout().withName("st_atim"),
+        timespec.layout().withName("st_mtim"),
+        timespec.layout().withName("st_ctim"),
+        MemoryLayout.sequenceLayout(2, fuse_h.C_INT).withName("__glibc_reserved")
+    ).withName("stat");
+
+    /**
+     * The layout of this struct
+     */
+    public static final GroupLayout layout() {
+        return $LAYOUT;
+    }
+
+    private static final OfLong st_dev$LAYOUT = (OfLong)$LAYOUT.select(groupElement("st_dev"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * __dev_t st_dev
+     * }
+     */
+    public static final OfLong st_dev$layout() {
+        return st_dev$LAYOUT;
     }
-    public static VarHandle st_dev$VH() {
-        return constants$6.const$0;
+
+    private static final long st_dev$OFFSET = 0;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * __dev_t st_dev
+     * }
+     */
+    public static final long st_dev$offset() {
+        return st_dev$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned long st_dev;
+     * {@snippet lang=c :
+     * __dev_t st_dev
      * }
      */
-    public static long st_dev$get(MemorySegment seg) {
-        return (long)constants$6.const$0.get(seg);
+    public static long st_dev(MemorySegment struct) {
+        return struct.get(st_dev$LAYOUT, st_dev$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned long st_dev;
+     * {@snippet lang=c :
+     * __dev_t st_dev
      * }
      */
-    public static void st_dev$set(MemorySegment seg, long x) {
-        constants$6.const$0.set(seg, x);
+    public static void st_dev(MemorySegment struct, long fieldValue) {
+        struct.set(st_dev$LAYOUT, st_dev$OFFSET, fieldValue);
     }
-    public static long st_dev$get(MemorySegment seg, long index) {
-        return (long)constants$6.const$0.get(seg.asSlice(index*sizeof()));
-    }
-    public static void st_dev$set(MemorySegment seg, long index, long x) {
-        constants$6.const$0.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfLong st_ino$LAYOUT = (OfLong)$LAYOUT.select(groupElement("st_ino"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * __ino64_t st_ino
+     * }
+     */
+    public static final OfLong st_ino$layout() {
+        return st_ino$LAYOUT;
     }
-    public static VarHandle st_ino$VH() {
-        return constants$6.const$1;
+
+    private static final long st_ino$OFFSET = 8;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * __ino64_t st_ino
+     * }
+     */
+    public static final long st_ino$offset() {
+        return st_ino$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned long st_ino;
+     * {@snippet lang=c :
+     * __ino64_t st_ino
      * }
      */
-    public static long st_ino$get(MemorySegment seg) {
-        return (long)constants$6.const$1.get(seg);
+    public static long st_ino(MemorySegment struct) {
+        return struct.get(st_ino$LAYOUT, st_ino$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned long st_ino;
+     * {@snippet lang=c :
+     * __ino64_t st_ino
      * }
      */
-    public static void st_ino$set(MemorySegment seg, long x) {
-        constants$6.const$1.set(seg, x);
+    public static void st_ino(MemorySegment struct, long fieldValue) {
+        struct.set(st_ino$LAYOUT, st_ino$OFFSET, fieldValue);
     }
-    public static long st_ino$get(MemorySegment seg, long index) {
-        return (long)constants$6.const$1.get(seg.asSlice(index*sizeof()));
-    }
-    public static void st_ino$set(MemorySegment seg, long index, long x) {
-        constants$6.const$1.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt st_mode$LAYOUT = (OfInt)$LAYOUT.select(groupElement("st_mode"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * __mode_t st_mode
+     * }
+     */
+    public static final OfInt st_mode$layout() {
+        return st_mode$LAYOUT;
     }
-    public static VarHandle st_mode$VH() {
-        return constants$6.const$2;
+
+    private static final long st_mode$OFFSET = 16;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * __mode_t st_mode
+     * }
+     */
+    public static final long st_mode$offset() {
+        return st_mode$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned int st_mode;
+     * {@snippet lang=c :
+     * __mode_t st_mode
      * }
      */
-    public static int st_mode$get(MemorySegment seg) {
-        return (int)constants$6.const$2.get(seg);
+    public static int st_mode(MemorySegment struct) {
+        return struct.get(st_mode$LAYOUT, st_mode$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned int st_mode;
+     * {@snippet lang=c :
+     * __mode_t st_mode
      * }
      */
-    public static void st_mode$set(MemorySegment seg, int x) {
-        constants$6.const$2.set(seg, x);
-    }
-    public static int st_mode$get(MemorySegment seg, long index) {
-        return (int)constants$6.const$2.get(seg.asSlice(index*sizeof()));
+    public static void st_mode(MemorySegment struct, int fieldValue) {
+        struct.set(st_mode$LAYOUT, st_mode$OFFSET, fieldValue);
     }
-    public static void st_mode$set(MemorySegment seg, long index, int x) {
-        constants$6.const$2.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt st_nlink$LAYOUT = (OfInt)$LAYOUT.select(groupElement("st_nlink"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * __nlink_t st_nlink
+     * }
+     */
+    public static final OfInt st_nlink$layout() {
+        return st_nlink$LAYOUT;
     }
-    public static VarHandle st_nlink$VH() {
-        return constants$6.const$3;
+
+    private static final long st_nlink$OFFSET = 20;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * __nlink_t st_nlink
+     * }
+     */
+    public static final long st_nlink$offset() {
+        return st_nlink$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned int st_nlink;
+     * {@snippet lang=c :
+     * __nlink_t st_nlink
      * }
      */
-    public static int st_nlink$get(MemorySegment seg) {
-        return (int)constants$6.const$3.get(seg);
+    public static int st_nlink(MemorySegment struct) {
+        return struct.get(st_nlink$LAYOUT, st_nlink$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned int st_nlink;
+     * {@snippet lang=c :
+     * __nlink_t st_nlink
      * }
      */
-    public static void st_nlink$set(MemorySegment seg, int x) {
-        constants$6.const$3.set(seg, x);
-    }
-    public static int st_nlink$get(MemorySegment seg, long index) {
-        return (int)constants$6.const$3.get(seg.asSlice(index*sizeof()));
+    public static void st_nlink(MemorySegment struct, int fieldValue) {
+        struct.set(st_nlink$LAYOUT, st_nlink$OFFSET, fieldValue);
     }
-    public static void st_nlink$set(MemorySegment seg, long index, int x) {
-        constants$6.const$3.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt st_uid$LAYOUT = (OfInt)$LAYOUT.select(groupElement("st_uid"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * __uid_t st_uid
+     * }
+     */
+    public static final OfInt st_uid$layout() {
+        return st_uid$LAYOUT;
     }
-    public static VarHandle st_uid$VH() {
-        return constants$6.const$4;
+
+    private static final long st_uid$OFFSET = 24;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * __uid_t st_uid
+     * }
+     */
+    public static final long st_uid$offset() {
+        return st_uid$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned int st_uid;
+     * {@snippet lang=c :
+     * __uid_t st_uid
      * }
      */
-    public static int st_uid$get(MemorySegment seg) {
-        return (int)constants$6.const$4.get(seg);
+    public static int st_uid(MemorySegment struct) {
+        return struct.get(st_uid$LAYOUT, st_uid$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned int st_uid;
+     * {@snippet lang=c :
+     * __uid_t st_uid
      * }
      */
-    public static void st_uid$set(MemorySegment seg, int x) {
-        constants$6.const$4.set(seg, x);
+    public static void st_uid(MemorySegment struct, int fieldValue) {
+        struct.set(st_uid$LAYOUT, st_uid$OFFSET, fieldValue);
     }
-    public static int st_uid$get(MemorySegment seg, long index) {
-        return (int)constants$6.const$4.get(seg.asSlice(index*sizeof()));
-    }
-    public static void st_uid$set(MemorySegment seg, long index, int x) {
-        constants$6.const$4.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt st_gid$LAYOUT = (OfInt)$LAYOUT.select(groupElement("st_gid"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * __gid_t st_gid
+     * }
+     */
+    public static final OfInt st_gid$layout() {
+        return st_gid$LAYOUT;
     }
-    public static VarHandle st_gid$VH() {
-        return constants$6.const$5;
+
+    private static final long st_gid$OFFSET = 28;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * __gid_t st_gid
+     * }
+     */
+    public static final long st_gid$offset() {
+        return st_gid$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned int st_gid;
+     * {@snippet lang=c :
+     * __gid_t st_gid
      * }
      */
-    public static int st_gid$get(MemorySegment seg) {
-        return (int)constants$6.const$5.get(seg);
+    public static int st_gid(MemorySegment struct) {
+        return struct.get(st_gid$LAYOUT, st_gid$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned int st_gid;
+     * {@snippet lang=c :
+     * __gid_t st_gid
      * }
      */
-    public static void st_gid$set(MemorySegment seg, int x) {
-        constants$6.const$5.set(seg, x);
+    public static void st_gid(MemorySegment struct, int fieldValue) {
+        struct.set(st_gid$LAYOUT, st_gid$OFFSET, fieldValue);
     }
-    public static int st_gid$get(MemorySegment seg, long index) {
-        return (int)constants$6.const$5.get(seg.asSlice(index*sizeof()));
-    }
-    public static void st_gid$set(MemorySegment seg, long index, int x) {
-        constants$6.const$5.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfLong st_rdev$LAYOUT = (OfLong)$LAYOUT.select(groupElement("st_rdev"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * __dev_t st_rdev
+     * }
+     */
+    public static final OfLong st_rdev$layout() {
+        return st_rdev$LAYOUT;
     }
-    public static VarHandle st_rdev$VH() {
-        return constants$7.const$0;
+
+    private static final long st_rdev$OFFSET = 32;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * __dev_t st_rdev
+     * }
+     */
+    public static final long st_rdev$offset() {
+        return st_rdev$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned long st_rdev;
+     * {@snippet lang=c :
+     * __dev_t st_rdev
      * }
      */
-    public static long st_rdev$get(MemorySegment seg) {
-        return (long)constants$7.const$0.get(seg);
+    public static long st_rdev(MemorySegment struct) {
+        return struct.get(st_rdev$LAYOUT, st_rdev$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned long st_rdev;
+     * {@snippet lang=c :
+     * __dev_t st_rdev
      * }
      */
-    public static void st_rdev$set(MemorySegment seg, long x) {
-        constants$7.const$0.set(seg, x);
-    }
-    public static long st_rdev$get(MemorySegment seg, long index) {
-        return (long)constants$7.const$0.get(seg.asSlice(index*sizeof()));
+    public static void st_rdev(MemorySegment struct, long fieldValue) {
+        struct.set(st_rdev$LAYOUT, st_rdev$OFFSET, fieldValue);
     }
-    public static void st_rdev$set(MemorySegment seg, long index, long x) {
-        constants$7.const$0.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfLong __pad1$LAYOUT = (OfLong)$LAYOUT.select(groupElement("__pad1"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * __dev_t __pad1
+     * }
+     */
+    public static final OfLong __pad1$layout() {
+        return __pad1$LAYOUT;
     }
-    public static VarHandle __pad1$VH() {
-        return constants$7.const$1;
+
+    private static final long __pad1$OFFSET = 40;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * __dev_t __pad1
+     * }
+     */
+    public static final long __pad1$offset() {
+        return __pad1$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned long __pad1;
+     * {@snippet lang=c :
+     * __dev_t __pad1
      * }
      */
-    public static long __pad1$get(MemorySegment seg) {
-        return (long)constants$7.const$1.get(seg);
+    public static long __pad1(MemorySegment struct) {
+        return struct.get(__pad1$LAYOUT, __pad1$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned long __pad1;
+     * {@snippet lang=c :
+     * __dev_t __pad1
+     * }
+     */
+    public static void __pad1(MemorySegment struct, long fieldValue) {
+        struct.set(__pad1$LAYOUT, __pad1$OFFSET, fieldValue);
+    }
+
+    private static final OfLong st_size$LAYOUT = (OfLong)$LAYOUT.select(groupElement("st_size"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * __off64_t st_size
+     * }
+     */
+    public static final OfLong st_size$layout() {
+        return st_size$LAYOUT;
+    }
+
+    private static final long st_size$OFFSET = 48;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * __off64_t st_size
      * }
      */
-    public static void __pad1$set(MemorySegment seg, long x) {
-        constants$7.const$1.set(seg, x);
+    public static final long st_size$offset() {
+        return st_size$OFFSET;
     }
-    public static long __pad1$get(MemorySegment seg, long index) {
-        return (long)constants$7.const$1.get(seg.asSlice(index*sizeof()));
+
+    /**
+     * Getter for field:
+     * {@snippet lang=c :
+     * __off64_t st_size
+     * }
+     */
+    public static long st_size(MemorySegment struct) {
+        return struct.get(st_size$LAYOUT, st_size$OFFSET);
     }
-    public static void __pad1$set(MemorySegment seg, long index, long x) {
-        constants$7.const$1.set(seg.asSlice(index*sizeof()), x);
+
+    /**
+     * Setter for field:
+     * {@snippet lang=c :
+     * __off64_t st_size
+     * }
+     */
+    public static void st_size(MemorySegment struct, long fieldValue) {
+        struct.set(st_size$LAYOUT, st_size$OFFSET, fieldValue);
     }
-    public static VarHandle st_size$VH() {
-        return constants$7.const$2;
+
+    private static final OfInt st_blksize$LAYOUT = (OfInt)$LAYOUT.select(groupElement("st_blksize"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * __blksize_t st_blksize
+     * }
+     */
+    public static final OfInt st_blksize$layout() {
+        return st_blksize$LAYOUT;
     }
+
+    private static final long st_blksize$OFFSET = 56;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * __blksize_t st_blksize
+     * }
+     */
+    public static final long st_blksize$offset() {
+        return st_blksize$OFFSET;
+    }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * long st_size;
+     * {@snippet lang=c :
+     * __blksize_t st_blksize
      * }
      */
-    public static long st_size$get(MemorySegment seg) {
-        return (long)constants$7.const$2.get(seg);
+    public static int st_blksize(MemorySegment struct) {
+        return struct.get(st_blksize$LAYOUT, st_blksize$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * long st_size;
+     * {@snippet lang=c :
+     * __blksize_t st_blksize
+     * }
+     */
+    public static void st_blksize(MemorySegment struct, int fieldValue) {
+        struct.set(st_blksize$LAYOUT, st_blksize$OFFSET, fieldValue);
+    }
+
+    private static final OfInt __pad2$LAYOUT = (OfInt)$LAYOUT.select(groupElement("__pad2"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int __pad2
+     * }
+     */
+    public static final OfInt __pad2$layout() {
+        return __pad2$LAYOUT;
+    }
+
+    private static final long __pad2$OFFSET = 60;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int __pad2
+     * }
+     */
+    public static final long __pad2$offset() {
+        return __pad2$OFFSET;
+    }
+
+    /**
+     * Getter for field:
+     * {@snippet lang=c :
+     * int __pad2
      * }
      */
-    public static void st_size$set(MemorySegment seg, long x) {
-        constants$7.const$2.set(seg, x);
+    public static int __pad2(MemorySegment struct) {
+        return struct.get(__pad2$LAYOUT, __pad2$OFFSET);
     }
-    public static long st_size$get(MemorySegment seg, long index) {
-        return (long)constants$7.const$2.get(seg.asSlice(index*sizeof()));
+
+    /**
+     * Setter for field:
+     * {@snippet lang=c :
+     * int __pad2
+     * }
+     */
+    public static void __pad2(MemorySegment struct, int fieldValue) {
+        struct.set(__pad2$LAYOUT, __pad2$OFFSET, fieldValue);
     }
-    public static void st_size$set(MemorySegment seg, long index, long x) {
-        constants$7.const$2.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfLong st_blocks$LAYOUT = (OfLong)$LAYOUT.select(groupElement("st_blocks"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * __blkcnt64_t st_blocks
+     * }
+     */
+    public static final OfLong st_blocks$layout() {
+        return st_blocks$LAYOUT;
     }
-    public static VarHandle st_blksize$VH() {
-        return constants$7.const$3;
+
+    private static final long st_blocks$OFFSET = 64;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * __blkcnt64_t st_blocks
+     * }
+     */
+    public static final long st_blocks$offset() {
+        return st_blocks$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int st_blksize;
+     * {@snippet lang=c :
+     * __blkcnt64_t st_blocks
      * }
      */
-    public static int st_blksize$get(MemorySegment seg) {
-        return (int)constants$7.const$3.get(seg);
+    public static long st_blocks(MemorySegment struct) {
+        return struct.get(st_blocks$LAYOUT, st_blocks$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int st_blksize;
+     * {@snippet lang=c :
+     * __blkcnt64_t st_blocks
+     * }
+     */
+    public static void st_blocks(MemorySegment struct, long fieldValue) {
+        struct.set(st_blocks$LAYOUT, st_blocks$OFFSET, fieldValue);
+    }
+
+    private static final GroupLayout st_atim$LAYOUT = (GroupLayout)$LAYOUT.select(groupElement("st_atim"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * struct timespec st_atim
      * }
      */
-    public static void st_blksize$set(MemorySegment seg, int x) {
-        constants$7.const$3.set(seg, x);
+    public static final GroupLayout st_atim$layout() {
+        return st_atim$LAYOUT;
     }
-    public static int st_blksize$get(MemorySegment seg, long index) {
-        return (int)constants$7.const$3.get(seg.asSlice(index*sizeof()));
+
+    private static final long st_atim$OFFSET = 72;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * struct timespec st_atim
+     * }
+     */
+    public static final long st_atim$offset() {
+        return st_atim$OFFSET;
+    }
+
+    /**
+     * Getter for field:
+     * {@snippet lang=c :
+     * struct timespec st_atim
+     * }
+     */
+    public static MemorySegment st_atim(MemorySegment struct) {
+        return struct.asSlice(st_atim$OFFSET, st_atim$LAYOUT.byteSize());
     }
-    public static void st_blksize$set(MemorySegment seg, long index, int x) {
-        constants$7.const$3.set(seg.asSlice(index*sizeof()), x);
+
+    /**
+     * Setter for field:
+     * {@snippet lang=c :
+     * struct timespec st_atim
+     * }
+     */
+    public static void st_atim(MemorySegment struct, MemorySegment fieldValue) {
+        MemorySegment.copy(fieldValue, 0L, struct, st_atim$OFFSET, st_atim$LAYOUT.byteSize());
     }
-    public static VarHandle __pad2$VH() {
-        return constants$7.const$4;
+
+    private static final GroupLayout st_mtim$LAYOUT = (GroupLayout)$LAYOUT.select(groupElement("st_mtim"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * struct timespec st_mtim
+     * }
+     */
+    public static final GroupLayout st_mtim$layout() {
+        return st_mtim$LAYOUT;
     }
+
+    private static final long st_mtim$OFFSET = 88;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * struct timespec st_mtim
+     * }
+     */
+    public static final long st_mtim$offset() {
+        return st_mtim$OFFSET;
+    }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int __pad2;
+     * {@snippet lang=c :
+     * struct timespec st_mtim
      * }
      */
-    public static int __pad2$get(MemorySegment seg) {
-        return (int)constants$7.const$4.get(seg);
+    public static MemorySegment st_mtim(MemorySegment struct) {
+        return struct.asSlice(st_mtim$OFFSET, st_mtim$LAYOUT.byteSize());
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int __pad2;
+     * {@snippet lang=c :
+     * struct timespec st_mtim
+     * }
+     */
+    public static void st_mtim(MemorySegment struct, MemorySegment fieldValue) {
+        MemorySegment.copy(fieldValue, 0L, struct, st_mtim$OFFSET, st_mtim$LAYOUT.byteSize());
+    }
+
+    private static final GroupLayout st_ctim$LAYOUT = (GroupLayout)$LAYOUT.select(groupElement("st_ctim"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * struct timespec st_ctim
      * }
      */
-    public static void __pad2$set(MemorySegment seg, int x) {
-        constants$7.const$4.set(seg, x);
+    public static final GroupLayout st_ctim$layout() {
+        return st_ctim$LAYOUT;
     }
-    public static int __pad2$get(MemorySegment seg, long index) {
-        return (int)constants$7.const$4.get(seg.asSlice(index*sizeof()));
+
+    private static final long st_ctim$OFFSET = 104;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * struct timespec st_ctim
+     * }
+     */
+    public static final long st_ctim$offset() {
+        return st_ctim$OFFSET;
+    }
+
+    /**
+     * Getter for field:
+     * {@snippet lang=c :
+     * struct timespec st_ctim
+     * }
+     */
+    public static MemorySegment st_ctim(MemorySegment struct) {
+        return struct.asSlice(st_ctim$OFFSET, st_ctim$LAYOUT.byteSize());
     }
-    public static void __pad2$set(MemorySegment seg, long index, int x) {
-        constants$7.const$4.set(seg.asSlice(index*sizeof()), x);
+
+    /**
+     * Setter for field:
+     * {@snippet lang=c :
+     * struct timespec st_ctim
+     * }
+     */
+    public static void st_ctim(MemorySegment struct, MemorySegment fieldValue) {
+        MemorySegment.copy(fieldValue, 0L, struct, st_ctim$OFFSET, st_ctim$LAYOUT.byteSize());
     }
-    public static VarHandle st_blocks$VH() {
-        return constants$7.const$5;
+
+    private static final SequenceLayout __glibc_reserved$LAYOUT = (SequenceLayout)$LAYOUT.select(groupElement("__glibc_reserved"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int __glibc_reserved[2]
+     * }
+     */
+    public static final SequenceLayout __glibc_reserved$layout() {
+        return __glibc_reserved$LAYOUT;
     }
+
+    private static final long __glibc_reserved$OFFSET = 120;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int __glibc_reserved[2]
+     * }
+     */
+    public static final long __glibc_reserved$offset() {
+        return __glibc_reserved$OFFSET;
+    }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * long st_blocks;
+     * {@snippet lang=c :
+     * int __glibc_reserved[2]
      * }
      */
-    public static long st_blocks$get(MemorySegment seg) {
-        return (long)constants$7.const$5.get(seg);
+    public static MemorySegment __glibc_reserved(MemorySegment struct) {
+        return struct.asSlice(__glibc_reserved$OFFSET, __glibc_reserved$LAYOUT.byteSize());
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * long st_blocks;
+     * {@snippet lang=c :
+     * int __glibc_reserved[2]
      * }
      */
-    public static void st_blocks$set(MemorySegment seg, long x) {
-        constants$7.const$5.set(seg, x);
+    public static void __glibc_reserved(MemorySegment struct, MemorySegment fieldValue) {
+        MemorySegment.copy(fieldValue, 0L, struct, __glibc_reserved$OFFSET, __glibc_reserved$LAYOUT.byteSize());
     }
-    public static long st_blocks$get(MemorySegment seg, long index) {
-        return (long)constants$7.const$5.get(seg.asSlice(index*sizeof()));
+
+    private static long[] __glibc_reserved$DIMS = { 2 };
+
+    /**
+     * Dimensions for array field:
+     * {@snippet lang=c :
+     * int __glibc_reserved[2]
+     * }
+     */
+    public static long[] __glibc_reserved$dimensions() {
+        return __glibc_reserved$DIMS;
     }
-    public static void st_blocks$set(MemorySegment seg, long index, long x) {
-        constants$7.const$5.set(seg.asSlice(index*sizeof()), x);
+    private static final VarHandle __glibc_reserved$ELEM_HANDLE = __glibc_reserved$LAYOUT.varHandle(sequenceElement());
+
+    /**
+     * Indexed getter for field:
+     * {@snippet lang=c :
+     * int __glibc_reserved[2]
+     * }
+     */
+    public static int __glibc_reserved(MemorySegment struct, long index0) {
+        return (int)__glibc_reserved$ELEM_HANDLE.get(struct, 0L, index0);
     }
-    public static MemorySegment st_atim$slice(MemorySegment seg) {
-        return seg.asSlice(72, 16);
+
+    /**
+     * Indexed setter for field:
+     * {@snippet lang=c :
+     * int __glibc_reserved[2]
+     * }
+     */
+    public static void __glibc_reserved(MemorySegment struct, long index0, int fieldValue) {
+        __glibc_reserved$ELEM_HANDLE.set(struct, 0L, index0, fieldValue);
     }
-    public static MemorySegment st_mtim$slice(MemorySegment seg) {
-        return seg.asSlice(88, 16);
+
+    /**
+     * Obtains a slice of {@code arrayParam} which selects the array element at {@code index}.
+     * The returned segment has address {@code arrayParam.address() + index * layout().byteSize()}
+     */
+    public static MemorySegment asSlice(MemorySegment array, long index) {
+        return array.asSlice(layout().byteSize() * index);
     }
-    public static MemorySegment st_ctim$slice(MemorySegment seg) {
-        return seg.asSlice(104, 16);
+
+    /**
+     * The size (in bytes) of this struct
+     */
+    public static long sizeof() { return layout().byteSize(); }
+
+    /**
+     * Allocate a segment of size {@code layout().byteSize()} using {@code allocator}
+     */
+    public static MemorySegment allocate(SegmentAllocator allocator) {
+        return allocator.allocate(layout());
     }
-    public static MemorySegment __glibc_reserved$slice(MemorySegment seg) {
-        return seg.asSlice(120, 8);
+
+    /**
+     * Allocate an array of size {@code elementCount} using {@code allocator}.
+     * The returned segment has size {@code elementCount * layout().byteSize()}.
+     */
+    public static MemorySegment allocateArray(long elementCount, SegmentAllocator allocator) {
+        return allocator.allocate(MemoryLayout.sequenceLayout(elementCount, layout()));
     }
-    public static long sizeof() { return $LAYOUT().byteSize(); }
-    public static MemorySegment allocate(SegmentAllocator allocator) { return allocator.allocate($LAYOUT()); }
-    public static MemorySegment allocateArray(long len, SegmentAllocator allocator) {
-        return allocator.allocate(MemoryLayout.sequenceLayout(len, $LAYOUT()));
+
+    /**
+     * Reinterprets {@code addr} using target {@code arena} and {@code cleanupAction) (if any).
+     * The returned segment has size {@code layout().byteSize()}
+     */
+    public static MemorySegment reinterpret(MemorySegment addr, Arena arena, Consumer<MemorySegment> cleanup) {
+        return reinterpret(addr, 1, arena, cleanup);
     }
-    public static MemorySegment ofAddress(MemorySegment addr, Arena scope) { return RuntimeHelper.asArray(addr, $LAYOUT(), 1, scope); }
-}
 
+    /**
+     * Reinterprets {@code addr} using target {@code arena} and {@code cleanupAction) (if any).
+     * The returned segment has size {@code elementCount * layout().byteSize()}
+     */
+    public static MemorySegment reinterpret(MemorySegment addr, long elementCount, Arena arena, Consumer<MemorySegment> cleanup) {
+        return addr.reinterpret(layout().byteSize() * elementCount, arena, cleanup);
+    }
+}
 
diff --git a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/statvfs.java b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/statvfs.java
index 8a5317f7..fb0b41a0 100644
--- a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/statvfs.java
+++ b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/statvfs.java
@@ -2,340 +2,665 @@
 
 package org.cryptomator.jfuse.linux.aarch64.extr.fuse3;
 
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
+import java.lang.invoke.*;
 import java.lang.foreign.*;
+import java.nio.ByteOrder;
+import java.util.*;
+import java.util.function.*;
+import java.util.stream.*;
+
 import static java.lang.foreign.ValueLayout.*;
+import static java.lang.foreign.MemoryLayout.PathElement.*;
+
 /**
- * {@snippet :
+ * {@snippet lang=c :
  * struct statvfs {
  *     unsigned long f_bsize;
  *     unsigned long f_frsize;
- *     unsigned long f_blocks;
- *     unsigned long f_bfree;
- *     unsigned long f_bavail;
- *     unsigned long f_files;
- *     unsigned long f_ffree;
- *     unsigned long f_favail;
+ *     __fsblkcnt64_t f_blocks;
+ *     __fsblkcnt64_t f_bfree;
+ *     __fsblkcnt64_t f_bavail;
+ *     __fsfilcnt64_t f_files;
+ *     __fsfilcnt64_t f_ffree;
+ *     __fsfilcnt64_t f_favail;
  *     unsigned long f_fsid;
  *     unsigned long f_flag;
  *     unsigned long f_namemax;
  *     int __f_spare[6];
- * };
+ * }
  * }
  */
 public class statvfs {
 
-    public static MemoryLayout $LAYOUT() {
-        return constants$8.const$0;
+    statvfs() {
+        // Should not be called directly
     }
-    public static VarHandle f_bsize$VH() {
-        return constants$8.const$1;
+
+    private static final GroupLayout $LAYOUT = MemoryLayout.structLayout(
+        fuse_h.C_LONG.withName("f_bsize"),
+        fuse_h.C_LONG.withName("f_frsize"),
+        fuse_h.C_LONG.withName("f_blocks"),
+        fuse_h.C_LONG.withName("f_bfree"),
+        fuse_h.C_LONG.withName("f_bavail"),
+        fuse_h.C_LONG.withName("f_files"),
+        fuse_h.C_LONG.withName("f_ffree"),
+        fuse_h.C_LONG.withName("f_favail"),
+        fuse_h.C_LONG.withName("f_fsid"),
+        fuse_h.C_LONG.withName("f_flag"),
+        fuse_h.C_LONG.withName("f_namemax"),
+        MemoryLayout.sequenceLayout(6, fuse_h.C_INT).withName("__f_spare")
+    ).withName("statvfs");
+
+    /**
+     * The layout of this struct
+     */
+    public static final GroupLayout layout() {
+        return $LAYOUT;
     }
+
+    private static final OfLong f_bsize$LAYOUT = (OfLong)$LAYOUT.select(groupElement("f_bsize"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * unsigned long f_bsize
+     * }
+     */
+    public static final OfLong f_bsize$layout() {
+        return f_bsize$LAYOUT;
+    }
+
+    private static final long f_bsize$OFFSET = 0;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * unsigned long f_bsize
+     * }
+     */
+    public static final long f_bsize$offset() {
+        return f_bsize$OFFSET;
+    }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned long f_bsize;
+     * {@snippet lang=c :
+     * unsigned long f_bsize
      * }
      */
-    public static long f_bsize$get(MemorySegment seg) {
-        return (long)constants$8.const$1.get(seg);
+    public static long f_bsize(MemorySegment struct) {
+        return struct.get(f_bsize$LAYOUT, f_bsize$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned long f_bsize;
+     * {@snippet lang=c :
+     * unsigned long f_bsize
      * }
      */
-    public static void f_bsize$set(MemorySegment seg, long x) {
-        constants$8.const$1.set(seg, x);
-    }
-    public static long f_bsize$get(MemorySegment seg, long index) {
-        return (long)constants$8.const$1.get(seg.asSlice(index*sizeof()));
+    public static void f_bsize(MemorySegment struct, long fieldValue) {
+        struct.set(f_bsize$LAYOUT, f_bsize$OFFSET, fieldValue);
     }
-    public static void f_bsize$set(MemorySegment seg, long index, long x) {
-        constants$8.const$1.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfLong f_frsize$LAYOUT = (OfLong)$LAYOUT.select(groupElement("f_frsize"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * unsigned long f_frsize
+     * }
+     */
+    public static final OfLong f_frsize$layout() {
+        return f_frsize$LAYOUT;
     }
-    public static VarHandle f_frsize$VH() {
-        return constants$8.const$2;
+
+    private static final long f_frsize$OFFSET = 8;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * unsigned long f_frsize
+     * }
+     */
+    public static final long f_frsize$offset() {
+        return f_frsize$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned long f_frsize;
+     * {@snippet lang=c :
+     * unsigned long f_frsize
      * }
      */
-    public static long f_frsize$get(MemorySegment seg) {
-        return (long)constants$8.const$2.get(seg);
+    public static long f_frsize(MemorySegment struct) {
+        return struct.get(f_frsize$LAYOUT, f_frsize$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned long f_frsize;
+     * {@snippet lang=c :
+     * unsigned long f_frsize
      * }
      */
-    public static void f_frsize$set(MemorySegment seg, long x) {
-        constants$8.const$2.set(seg, x);
-    }
-    public static long f_frsize$get(MemorySegment seg, long index) {
-        return (long)constants$8.const$2.get(seg.asSlice(index*sizeof()));
+    public static void f_frsize(MemorySegment struct, long fieldValue) {
+        struct.set(f_frsize$LAYOUT, f_frsize$OFFSET, fieldValue);
     }
-    public static void f_frsize$set(MemorySegment seg, long index, long x) {
-        constants$8.const$2.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfLong f_blocks$LAYOUT = (OfLong)$LAYOUT.select(groupElement("f_blocks"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * __fsblkcnt64_t f_blocks
+     * }
+     */
+    public static final OfLong f_blocks$layout() {
+        return f_blocks$LAYOUT;
     }
-    public static VarHandle f_blocks$VH() {
-        return constants$8.const$3;
+
+    private static final long f_blocks$OFFSET = 16;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * __fsblkcnt64_t f_blocks
+     * }
+     */
+    public static final long f_blocks$offset() {
+        return f_blocks$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned long f_blocks;
+     * {@snippet lang=c :
+     * __fsblkcnt64_t f_blocks
      * }
      */
-    public static long f_blocks$get(MemorySegment seg) {
-        return (long)constants$8.const$3.get(seg);
+    public static long f_blocks(MemorySegment struct) {
+        return struct.get(f_blocks$LAYOUT, f_blocks$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned long f_blocks;
+     * {@snippet lang=c :
+     * __fsblkcnt64_t f_blocks
      * }
      */
-    public static void f_blocks$set(MemorySegment seg, long x) {
-        constants$8.const$3.set(seg, x);
-    }
-    public static long f_blocks$get(MemorySegment seg, long index) {
-        return (long)constants$8.const$3.get(seg.asSlice(index*sizeof()));
+    public static void f_blocks(MemorySegment struct, long fieldValue) {
+        struct.set(f_blocks$LAYOUT, f_blocks$OFFSET, fieldValue);
     }
-    public static void f_blocks$set(MemorySegment seg, long index, long x) {
-        constants$8.const$3.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfLong f_bfree$LAYOUT = (OfLong)$LAYOUT.select(groupElement("f_bfree"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * __fsblkcnt64_t f_bfree
+     * }
+     */
+    public static final OfLong f_bfree$layout() {
+        return f_bfree$LAYOUT;
     }
-    public static VarHandle f_bfree$VH() {
-        return constants$8.const$4;
+
+    private static final long f_bfree$OFFSET = 24;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * __fsblkcnt64_t f_bfree
+     * }
+     */
+    public static final long f_bfree$offset() {
+        return f_bfree$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned long f_bfree;
+     * {@snippet lang=c :
+     * __fsblkcnt64_t f_bfree
      * }
      */
-    public static long f_bfree$get(MemorySegment seg) {
-        return (long)constants$8.const$4.get(seg);
+    public static long f_bfree(MemorySegment struct) {
+        return struct.get(f_bfree$LAYOUT, f_bfree$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned long f_bfree;
+     * {@snippet lang=c :
+     * __fsblkcnt64_t f_bfree
      * }
      */
-    public static void f_bfree$set(MemorySegment seg, long x) {
-        constants$8.const$4.set(seg, x);
+    public static void f_bfree(MemorySegment struct, long fieldValue) {
+        struct.set(f_bfree$LAYOUT, f_bfree$OFFSET, fieldValue);
     }
-    public static long f_bfree$get(MemorySegment seg, long index) {
-        return (long)constants$8.const$4.get(seg.asSlice(index*sizeof()));
-    }
-    public static void f_bfree$set(MemorySegment seg, long index, long x) {
-        constants$8.const$4.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfLong f_bavail$LAYOUT = (OfLong)$LAYOUT.select(groupElement("f_bavail"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * __fsblkcnt64_t f_bavail
+     * }
+     */
+    public static final OfLong f_bavail$layout() {
+        return f_bavail$LAYOUT;
     }
-    public static VarHandle f_bavail$VH() {
-        return constants$8.const$5;
+
+    private static final long f_bavail$OFFSET = 32;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * __fsblkcnt64_t f_bavail
+     * }
+     */
+    public static final long f_bavail$offset() {
+        return f_bavail$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned long f_bavail;
+     * {@snippet lang=c :
+     * __fsblkcnt64_t f_bavail
      * }
      */
-    public static long f_bavail$get(MemorySegment seg) {
-        return (long)constants$8.const$5.get(seg);
+    public static long f_bavail(MemorySegment struct) {
+        return struct.get(f_bavail$LAYOUT, f_bavail$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned long f_bavail;
+     * {@snippet lang=c :
+     * __fsblkcnt64_t f_bavail
      * }
      */
-    public static void f_bavail$set(MemorySegment seg, long x) {
-        constants$8.const$5.set(seg, x);
-    }
-    public static long f_bavail$get(MemorySegment seg, long index) {
-        return (long)constants$8.const$5.get(seg.asSlice(index*sizeof()));
+    public static void f_bavail(MemorySegment struct, long fieldValue) {
+        struct.set(f_bavail$LAYOUT, f_bavail$OFFSET, fieldValue);
     }
-    public static void f_bavail$set(MemorySegment seg, long index, long x) {
-        constants$8.const$5.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfLong f_files$LAYOUT = (OfLong)$LAYOUT.select(groupElement("f_files"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * __fsfilcnt64_t f_files
+     * }
+     */
+    public static final OfLong f_files$layout() {
+        return f_files$LAYOUT;
     }
-    public static VarHandle f_files$VH() {
-        return constants$9.const$0;
+
+    private static final long f_files$OFFSET = 40;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * __fsfilcnt64_t f_files
+     * }
+     */
+    public static final long f_files$offset() {
+        return f_files$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned long f_files;
+     * {@snippet lang=c :
+     * __fsfilcnt64_t f_files
      * }
      */
-    public static long f_files$get(MemorySegment seg) {
-        return (long)constants$9.const$0.get(seg);
+    public static long f_files(MemorySegment struct) {
+        return struct.get(f_files$LAYOUT, f_files$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned long f_files;
+     * {@snippet lang=c :
+     * __fsfilcnt64_t f_files
      * }
      */
-    public static void f_files$set(MemorySegment seg, long x) {
-        constants$9.const$0.set(seg, x);
-    }
-    public static long f_files$get(MemorySegment seg, long index) {
-        return (long)constants$9.const$0.get(seg.asSlice(index*sizeof()));
+    public static void f_files(MemorySegment struct, long fieldValue) {
+        struct.set(f_files$LAYOUT, f_files$OFFSET, fieldValue);
     }
-    public static void f_files$set(MemorySegment seg, long index, long x) {
-        constants$9.const$0.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfLong f_ffree$LAYOUT = (OfLong)$LAYOUT.select(groupElement("f_ffree"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * __fsfilcnt64_t f_ffree
+     * }
+     */
+    public static final OfLong f_ffree$layout() {
+        return f_ffree$LAYOUT;
     }
-    public static VarHandle f_ffree$VH() {
-        return constants$9.const$1;
+
+    private static final long f_ffree$OFFSET = 48;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * __fsfilcnt64_t f_ffree
+     * }
+     */
+    public static final long f_ffree$offset() {
+        return f_ffree$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned long f_ffree;
+     * {@snippet lang=c :
+     * __fsfilcnt64_t f_ffree
      * }
      */
-    public static long f_ffree$get(MemorySegment seg) {
-        return (long)constants$9.const$1.get(seg);
+    public static long f_ffree(MemorySegment struct) {
+        return struct.get(f_ffree$LAYOUT, f_ffree$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned long f_ffree;
+     * {@snippet lang=c :
+     * __fsfilcnt64_t f_ffree
      * }
      */
-    public static void f_ffree$set(MemorySegment seg, long x) {
-        constants$9.const$1.set(seg, x);
-    }
-    public static long f_ffree$get(MemorySegment seg, long index) {
-        return (long)constants$9.const$1.get(seg.asSlice(index*sizeof()));
+    public static void f_ffree(MemorySegment struct, long fieldValue) {
+        struct.set(f_ffree$LAYOUT, f_ffree$OFFSET, fieldValue);
     }
-    public static void f_ffree$set(MemorySegment seg, long index, long x) {
-        constants$9.const$1.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfLong f_favail$LAYOUT = (OfLong)$LAYOUT.select(groupElement("f_favail"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * __fsfilcnt64_t f_favail
+     * }
+     */
+    public static final OfLong f_favail$layout() {
+        return f_favail$LAYOUT;
     }
-    public static VarHandle f_favail$VH() {
-        return constants$9.const$2;
+
+    private static final long f_favail$OFFSET = 56;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * __fsfilcnt64_t f_favail
+     * }
+     */
+    public static final long f_favail$offset() {
+        return f_favail$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned long f_favail;
+     * {@snippet lang=c :
+     * __fsfilcnt64_t f_favail
      * }
      */
-    public static long f_favail$get(MemorySegment seg) {
-        return (long)constants$9.const$2.get(seg);
+    public static long f_favail(MemorySegment struct) {
+        return struct.get(f_favail$LAYOUT, f_favail$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned long f_favail;
+     * {@snippet lang=c :
+     * __fsfilcnt64_t f_favail
      * }
      */
-    public static void f_favail$set(MemorySegment seg, long x) {
-        constants$9.const$2.set(seg, x);
-    }
-    public static long f_favail$get(MemorySegment seg, long index) {
-        return (long)constants$9.const$2.get(seg.asSlice(index*sizeof()));
+    public static void f_favail(MemorySegment struct, long fieldValue) {
+        struct.set(f_favail$LAYOUT, f_favail$OFFSET, fieldValue);
     }
-    public static void f_favail$set(MemorySegment seg, long index, long x) {
-        constants$9.const$2.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfLong f_fsid$LAYOUT = (OfLong)$LAYOUT.select(groupElement("f_fsid"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * unsigned long f_fsid
+     * }
+     */
+    public static final OfLong f_fsid$layout() {
+        return f_fsid$LAYOUT;
     }
-    public static VarHandle f_fsid$VH() {
-        return constants$9.const$3;
+
+    private static final long f_fsid$OFFSET = 64;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * unsigned long f_fsid
+     * }
+     */
+    public static final long f_fsid$offset() {
+        return f_fsid$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned long f_fsid;
+     * {@snippet lang=c :
+     * unsigned long f_fsid
      * }
      */
-    public static long f_fsid$get(MemorySegment seg) {
-        return (long)constants$9.const$3.get(seg);
+    public static long f_fsid(MemorySegment struct) {
+        return struct.get(f_fsid$LAYOUT, f_fsid$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned long f_fsid;
+     * {@snippet lang=c :
+     * unsigned long f_fsid
      * }
      */
-    public static void f_fsid$set(MemorySegment seg, long x) {
-        constants$9.const$3.set(seg, x);
+    public static void f_fsid(MemorySegment struct, long fieldValue) {
+        struct.set(f_fsid$LAYOUT, f_fsid$OFFSET, fieldValue);
     }
-    public static long f_fsid$get(MemorySegment seg, long index) {
-        return (long)constants$9.const$3.get(seg.asSlice(index*sizeof()));
-    }
-    public static void f_fsid$set(MemorySegment seg, long index, long x) {
-        constants$9.const$3.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfLong f_flag$LAYOUT = (OfLong)$LAYOUT.select(groupElement("f_flag"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * unsigned long f_flag
+     * }
+     */
+    public static final OfLong f_flag$layout() {
+        return f_flag$LAYOUT;
     }
-    public static VarHandle f_flag$VH() {
-        return constants$9.const$4;
+
+    private static final long f_flag$OFFSET = 72;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * unsigned long f_flag
+     * }
+     */
+    public static final long f_flag$offset() {
+        return f_flag$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned long f_flag;
+     * {@snippet lang=c :
+     * unsigned long f_flag
      * }
      */
-    public static long f_flag$get(MemorySegment seg) {
-        return (long)constants$9.const$4.get(seg);
+    public static long f_flag(MemorySegment struct) {
+        return struct.get(f_flag$LAYOUT, f_flag$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned long f_flag;
+     * {@snippet lang=c :
+     * unsigned long f_flag
      * }
      */
-    public static void f_flag$set(MemorySegment seg, long x) {
-        constants$9.const$4.set(seg, x);
+    public static void f_flag(MemorySegment struct, long fieldValue) {
+        struct.set(f_flag$LAYOUT, f_flag$OFFSET, fieldValue);
     }
-    public static long f_flag$get(MemorySegment seg, long index) {
-        return (long)constants$9.const$4.get(seg.asSlice(index*sizeof()));
+
+    private static final OfLong f_namemax$LAYOUT = (OfLong)$LAYOUT.select(groupElement("f_namemax"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * unsigned long f_namemax
+     * }
+     */
+    public static final OfLong f_namemax$layout() {
+        return f_namemax$LAYOUT;
     }
-    public static void f_flag$set(MemorySegment seg, long index, long x) {
-        constants$9.const$4.set(seg.asSlice(index*sizeof()), x);
+
+    private static final long f_namemax$OFFSET = 80;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * unsigned long f_namemax
+     * }
+     */
+    public static final long f_namemax$offset() {
+        return f_namemax$OFFSET;
     }
-    public static VarHandle f_namemax$VH() {
-        return constants$9.const$5;
+
+    /**
+     * Getter for field:
+     * {@snippet lang=c :
+     * unsigned long f_namemax
+     * }
+     */
+    public static long f_namemax(MemorySegment struct) {
+        return struct.get(f_namemax$LAYOUT, f_namemax$OFFSET);
     }
+
+    /**
+     * Setter for field:
+     * {@snippet lang=c :
+     * unsigned long f_namemax
+     * }
+     */
+    public static void f_namemax(MemorySegment struct, long fieldValue) {
+        struct.set(f_namemax$LAYOUT, f_namemax$OFFSET, fieldValue);
+    }
+
+    private static final SequenceLayout __f_spare$LAYOUT = (SequenceLayout)$LAYOUT.select(groupElement("__f_spare"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int __f_spare[6]
+     * }
+     */
+    public static final SequenceLayout __f_spare$layout() {
+        return __f_spare$LAYOUT;
+    }
+
+    private static final long __f_spare$OFFSET = 88;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int __f_spare[6]
+     * }
+     */
+    public static final long __f_spare$offset() {
+        return __f_spare$OFFSET;
+    }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned long f_namemax;
+     * {@snippet lang=c :
+     * int __f_spare[6]
      * }
      */
-    public static long f_namemax$get(MemorySegment seg) {
-        return (long)constants$9.const$5.get(seg);
+    public static MemorySegment __f_spare(MemorySegment struct) {
+        return struct.asSlice(__f_spare$OFFSET, __f_spare$LAYOUT.byteSize());
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned long f_namemax;
+     * {@snippet lang=c :
+     * int __f_spare[6]
+     * }
+     */
+    public static void __f_spare(MemorySegment struct, MemorySegment fieldValue) {
+        MemorySegment.copy(fieldValue, 0L, struct, __f_spare$OFFSET, __f_spare$LAYOUT.byteSize());
+    }
+
+    private static long[] __f_spare$DIMS = { 6 };
+
+    /**
+     * Dimensions for array field:
+     * {@snippet lang=c :
+     * int __f_spare[6]
+     * }
+     */
+    public static long[] __f_spare$dimensions() {
+        return __f_spare$DIMS;
+    }
+    private static final VarHandle __f_spare$ELEM_HANDLE = __f_spare$LAYOUT.varHandle(sequenceElement());
+
+    /**
+     * Indexed getter for field:
+     * {@snippet lang=c :
+     * int __f_spare[6]
      * }
      */
-    public static void f_namemax$set(MemorySegment seg, long x) {
-        constants$9.const$5.set(seg, x);
+    public static int __f_spare(MemorySegment struct, long index0) {
+        return (int)__f_spare$ELEM_HANDLE.get(struct, 0L, index0);
     }
-    public static long f_namemax$get(MemorySegment seg, long index) {
-        return (long)constants$9.const$5.get(seg.asSlice(index*sizeof()));
+
+    /**
+     * Indexed setter for field:
+     * {@snippet lang=c :
+     * int __f_spare[6]
+     * }
+     */
+    public static void __f_spare(MemorySegment struct, long index0, int fieldValue) {
+        __f_spare$ELEM_HANDLE.set(struct, 0L, index0, fieldValue);
+    }
+
+    /**
+     * Obtains a slice of {@code arrayParam} which selects the array element at {@code index}.
+     * The returned segment has address {@code arrayParam.address() + index * layout().byteSize()}
+     */
+    public static MemorySegment asSlice(MemorySegment array, long index) {
+        return array.asSlice(layout().byteSize() * index);
+    }
+
+    /**
+     * The size (in bytes) of this struct
+     */
+    public static long sizeof() { return layout().byteSize(); }
+
+    /**
+     * Allocate a segment of size {@code layout().byteSize()} using {@code allocator}
+     */
+    public static MemorySegment allocate(SegmentAllocator allocator) {
+        return allocator.allocate(layout());
     }
-    public static void f_namemax$set(MemorySegment seg, long index, long x) {
-        constants$9.const$5.set(seg.asSlice(index*sizeof()), x);
+
+    /**
+     * Allocate an array of size {@code elementCount} using {@code allocator}.
+     * The returned segment has size {@code elementCount * layout().byteSize()}.
+     */
+    public static MemorySegment allocateArray(long elementCount, SegmentAllocator allocator) {
+        return allocator.allocate(MemoryLayout.sequenceLayout(elementCount, layout()));
     }
-    public static MemorySegment __f_spare$slice(MemorySegment seg) {
-        return seg.asSlice(88, 24);
+
+    /**
+     * Reinterprets {@code addr} using target {@code arena} and {@code cleanupAction) (if any).
+     * The returned segment has size {@code layout().byteSize()}
+     */
+    public static MemorySegment reinterpret(MemorySegment addr, Arena arena, Consumer<MemorySegment> cleanup) {
+        return reinterpret(addr, 1, arena, cleanup);
     }
-    public static long sizeof() { return $LAYOUT().byteSize(); }
-    public static MemorySegment allocate(SegmentAllocator allocator) { return allocator.allocate($LAYOUT()); }
-    public static MemorySegment allocateArray(long len, SegmentAllocator allocator) {
-        return allocator.allocate(MemoryLayout.sequenceLayout(len, $LAYOUT()));
+
+    /**
+     * Reinterprets {@code addr} using target {@code arena} and {@code cleanupAction) (if any).
+     * The returned segment has size {@code elementCount * layout().byteSize()}
+     */
+    public static MemorySegment reinterpret(MemorySegment addr, long elementCount, Arena arena, Consumer<MemorySegment> cleanup) {
+        return addr.reinterpret(layout().byteSize() * elementCount, arena, cleanup);
     }
-    public static MemorySegment ofAddress(MemorySegment addr, Arena scope) { return RuntimeHelper.asArray(addr, $LAYOUT(), 1, scope); }
 }
 
-
diff --git a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/timespec.java b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/timespec.java
index 99610261..68ed024e 100644
--- a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/timespec.java
+++ b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3/timespec.java
@@ -2,84 +2,172 @@
 
 package org.cryptomator.jfuse.linux.aarch64.extr.fuse3;
 
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
+import java.lang.invoke.*;
 import java.lang.foreign.*;
+import java.nio.ByteOrder;
+import java.util.*;
+import java.util.function.*;
+import java.util.stream.*;
+
 import static java.lang.foreign.ValueLayout.*;
+import static java.lang.foreign.MemoryLayout.PathElement.*;
+
 /**
- * {@snippet :
+ * {@snippet lang=c :
  * struct timespec {
- *     long tv_sec;
- *     long tv_nsec;
- * };
+ *     __time_t tv_sec;
+ *     __syscall_slong_t tv_nsec;
+ * }
  * }
  */
 public class timespec {
 
-    public static MemoryLayout $LAYOUT() {
-        return constants$0.const$4;
+    timespec() {
+        // Should not be called directly
     }
-    public static VarHandle tv_sec$VH() {
-        return constants$0.const$5;
+
+    private static final GroupLayout $LAYOUT = MemoryLayout.structLayout(
+        fuse_h.C_LONG.withName("tv_sec"),
+        fuse_h.C_LONG.withName("tv_nsec")
+    ).withName("timespec");
+
+    /**
+     * The layout of this struct
+     */
+    public static final GroupLayout layout() {
+        return $LAYOUT;
     }
+
+    private static final OfLong tv_sec$LAYOUT = (OfLong)$LAYOUT.select(groupElement("tv_sec"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * __time_t tv_sec
+     * }
+     */
+    public static final OfLong tv_sec$layout() {
+        return tv_sec$LAYOUT;
+    }
+
+    private static final long tv_sec$OFFSET = 0;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * __time_t tv_sec
+     * }
+     */
+    public static final long tv_sec$offset() {
+        return tv_sec$OFFSET;
+    }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * long tv_sec;
+     * {@snippet lang=c :
+     * __time_t tv_sec
      * }
      */
-    public static long tv_sec$get(MemorySegment seg) {
-        return (long)constants$0.const$5.get(seg);
+    public static long tv_sec(MemorySegment struct) {
+        return struct.get(tv_sec$LAYOUT, tv_sec$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * long tv_sec;
+     * {@snippet lang=c :
+     * __time_t tv_sec
      * }
      */
-    public static void tv_sec$set(MemorySegment seg, long x) {
-        constants$0.const$5.set(seg, x);
-    }
-    public static long tv_sec$get(MemorySegment seg, long index) {
-        return (long)constants$0.const$5.get(seg.asSlice(index*sizeof()));
+    public static void tv_sec(MemorySegment struct, long fieldValue) {
+        struct.set(tv_sec$LAYOUT, tv_sec$OFFSET, fieldValue);
     }
-    public static void tv_sec$set(MemorySegment seg, long index, long x) {
-        constants$0.const$5.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfLong tv_nsec$LAYOUT = (OfLong)$LAYOUT.select(groupElement("tv_nsec"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * __syscall_slong_t tv_nsec
+     * }
+     */
+    public static final OfLong tv_nsec$layout() {
+        return tv_nsec$LAYOUT;
     }
-    public static VarHandle tv_nsec$VH() {
-        return constants$1.const$0;
+
+    private static final long tv_nsec$OFFSET = 8;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * __syscall_slong_t tv_nsec
+     * }
+     */
+    public static final long tv_nsec$offset() {
+        return tv_nsec$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * long tv_nsec;
+     * {@snippet lang=c :
+     * __syscall_slong_t tv_nsec
      * }
      */
-    public static long tv_nsec$get(MemorySegment seg) {
-        return (long)constants$1.const$0.get(seg);
+    public static long tv_nsec(MemorySegment struct) {
+        return struct.get(tv_nsec$LAYOUT, tv_nsec$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * long tv_nsec;
+     * {@snippet lang=c :
+     * __syscall_slong_t tv_nsec
      * }
      */
-    public static void tv_nsec$set(MemorySegment seg, long x) {
-        constants$1.const$0.set(seg, x);
+    public static void tv_nsec(MemorySegment struct, long fieldValue) {
+        struct.set(tv_nsec$LAYOUT, tv_nsec$OFFSET, fieldValue);
+    }
+
+    /**
+     * Obtains a slice of {@code arrayParam} which selects the array element at {@code index}.
+     * The returned segment has address {@code arrayParam.address() + index * layout().byteSize()}
+     */
+    public static MemorySegment asSlice(MemorySegment array, long index) {
+        return array.asSlice(layout().byteSize() * index);
+    }
+
+    /**
+     * The size (in bytes) of this struct
+     */
+    public static long sizeof() { return layout().byteSize(); }
+
+    /**
+     * Allocate a segment of size {@code layout().byteSize()} using {@code allocator}
+     */
+    public static MemorySegment allocate(SegmentAllocator allocator) {
+        return allocator.allocate(layout());
     }
-    public static long tv_nsec$get(MemorySegment seg, long index) {
-        return (long)constants$1.const$0.get(seg.asSlice(index*sizeof()));
+
+    /**
+     * Allocate an array of size {@code elementCount} using {@code allocator}.
+     * The returned segment has size {@code elementCount * layout().byteSize()}.
+     */
+    public static MemorySegment allocateArray(long elementCount, SegmentAllocator allocator) {
+        return allocator.allocate(MemoryLayout.sequenceLayout(elementCount, layout()));
     }
-    public static void tv_nsec$set(MemorySegment seg, long index, long x) {
-        constants$1.const$0.set(seg.asSlice(index*sizeof()), x);
+
+    /**
+     * Reinterprets {@code addr} using target {@code arena} and {@code cleanupAction) (if any).
+     * The returned segment has size {@code layout().byteSize()}
+     */
+    public static MemorySegment reinterpret(MemorySegment addr, Arena arena, Consumer<MemorySegment> cleanup) {
+        return reinterpret(addr, 1, arena, cleanup);
     }
-    public static long sizeof() { return $LAYOUT().byteSize(); }
-    public static MemorySegment allocate(SegmentAllocator allocator) { return allocator.allocate($LAYOUT()); }
-    public static MemorySegment allocateArray(long len, SegmentAllocator allocator) {
-        return allocator.allocate(MemoryLayout.sequenceLayout(len, $LAYOUT()));
+
+    /**
+     * Reinterprets {@code addr} using target {@code arena} and {@code cleanupAction) (if any).
+     * The returned segment has size {@code elementCount * layout().byteSize()}
+     */
+    public static MemorySegment reinterpret(MemorySegment addr, long elementCount, Arena arena, Consumer<MemorySegment> cleanup) {
+        return addr.reinterpret(layout().byteSize() * elementCount, arena, cleanup);
     }
-    public static MemorySegment ofAddress(MemorySegment addr, Arena scope) { return RuntimeHelper.asArray(addr, $LAYOUT(), 1, scope); }
 }
 
-
diff --git a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3_lowlevel/RuntimeHelper.java b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3_lowlevel/RuntimeHelper.java
deleted file mode 100644
index 9fb80431..00000000
--- a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3_lowlevel/RuntimeHelper.java
+++ /dev/null
@@ -1,245 +0,0 @@
-package org.cryptomator.jfuse.linux.aarch64.extr.fuse3_lowlevel;
-// Generated by jextract
-
-import java.lang.foreign.Linker;
-import java.lang.foreign.FunctionDescriptor;
-import java.lang.foreign.GroupLayout;
-import java.lang.foreign.SymbolLookup;
-import java.lang.foreign.MemoryLayout;
-import java.lang.foreign.MemorySegment;
-import java.lang.foreign.Arena;
-import java.lang.foreign.SegmentAllocator;
-import java.lang.foreign.ValueLayout;
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.MethodHandles;
-import java.lang.invoke.MethodType;
-import java.io.File;
-import java.nio.file.Path;
-import java.nio.charset.StandardCharsets;
-import java.util.Arrays;
-import java.util.Optional;
-import java.util.stream.Stream;
-
-import java.lang.foreign.AddressLayout;
-import java.lang.foreign.MemoryLayout;
-
-import static java.lang.foreign.Linker.*;
-import static java.lang.foreign.ValueLayout.*;
-
-final class RuntimeHelper {
-
-    private static final Linker LINKER = Linker.nativeLinker();
-    private static final ClassLoader LOADER = RuntimeHelper.class.getClassLoader();
-    private static final MethodHandles.Lookup MH_LOOKUP = MethodHandles.lookup();
-    private static final SymbolLookup SYMBOL_LOOKUP;
-    private static final SegmentAllocator THROWING_ALLOCATOR = (x, y) -> { throw new AssertionError("should not reach here"); };
-    static final AddressLayout POINTER = ValueLayout.ADDRESS.withTargetLayout(MemoryLayout.sequenceLayout(JAVA_BYTE));
-
-    final static SegmentAllocator CONSTANT_ALLOCATOR =
-            (size, align) -> Arena.ofAuto().allocate(size, align);
-
-    static {
-        
-        SymbolLookup loaderLookup = SymbolLookup.loaderLookup();
-        SYMBOL_LOOKUP = name -> loaderLookup.find(name).or(() -> LINKER.defaultLookup().find(name));
-    }
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private RuntimeHelper() {}
-
-    static <T> T requireNonNull(T obj, String symbolName) {
-        if (obj == null) {
-            throw new UnsatisfiedLinkError("unresolved symbol: " + symbolName);
-        }
-        return obj;
-    }
-
-    static MemorySegment lookupGlobalVariable(String name, MemoryLayout layout) {
-        return SYMBOL_LOOKUP.find(name)
-                .map(s -> s.reinterpret(layout.byteSize()))
-                .orElse(null);
-    }
-
-    static MethodHandle downcallHandle(String name, FunctionDescriptor fdesc) {
-        return SYMBOL_LOOKUP.find(name).
-                map(addr -> LINKER.downcallHandle(addr, fdesc)).
-                orElse(null);
-    }
-
-    static MethodHandle downcallHandle(FunctionDescriptor fdesc) {
-        return LINKER.downcallHandle(fdesc);
-    }
-
-    static MethodHandle downcallHandleVariadic(String name, FunctionDescriptor fdesc) {
-        return SYMBOL_LOOKUP.find(name).
-                map(addr -> VarargsInvoker.make(addr, fdesc)).
-                orElse(null);
-    }
-
-    static MethodHandle upcallHandle(Class<?> fi, String name, FunctionDescriptor fdesc) {
-        try {
-            return MH_LOOKUP.findVirtual(fi, name, fdesc.toMethodType());
-        } catch (Throwable ex) {
-            throw new AssertionError(ex);
-        }
-    }
-
-    static <Z> MemorySegment upcallStub(MethodHandle fiHandle, Z z, FunctionDescriptor fdesc, Arena scope) {
-        try {
-            fiHandle = fiHandle.bindTo(z);
-            return LINKER.upcallStub(fiHandle, fdesc, scope);
-        } catch (Throwable ex) {
-            throw new AssertionError(ex);
-        }
-    }
-
-    static MemorySegment asArray(MemorySegment addr, MemoryLayout layout, int numElements, Arena arena) {
-         return addr.reinterpret(numElements * layout.byteSize(), arena, null);
-    }
-
-    // Internals only below this point
-
-    private static final class VarargsInvoker {
-        private static final MethodHandle INVOKE_MH;
-        private final MemorySegment symbol;
-        private final FunctionDescriptor function;
-
-        private VarargsInvoker(MemorySegment symbol, FunctionDescriptor function) {
-            this.symbol = symbol;
-            this.function = function;
-        }
-
-        static {
-            try {
-                INVOKE_MH = MethodHandles.lookup().findVirtual(VarargsInvoker.class, "invoke", MethodType.methodType(Object.class, SegmentAllocator.class, Object[].class));
-            } catch (ReflectiveOperationException e) {
-                throw new RuntimeException(e);
-            }
-        }
-
-        static MethodHandle make(MemorySegment symbol, FunctionDescriptor function) {
-            VarargsInvoker invoker = new VarargsInvoker(symbol, function);
-            MethodHandle handle = INVOKE_MH.bindTo(invoker).asCollector(Object[].class, function.argumentLayouts().size() + 1);
-            MethodType mtype = MethodType.methodType(function.returnLayout().isPresent() ? carrier(function.returnLayout().get(), true) : void.class);
-            for (MemoryLayout layout : function.argumentLayouts()) {
-                mtype = mtype.appendParameterTypes(carrier(layout, false));
-            }
-            mtype = mtype.appendParameterTypes(Object[].class);
-            boolean needsAllocator = function.returnLayout().isPresent() &&
-                                function.returnLayout().get() instanceof GroupLayout;
-            if (needsAllocator) {
-                mtype = mtype.insertParameterTypes(0, SegmentAllocator.class);
-            } else {
-                handle = MethodHandles.insertArguments(handle, 0, THROWING_ALLOCATOR);
-            }
-            return handle.asType(mtype);
-        }
-
-        static Class<?> carrier(MemoryLayout layout, boolean ret) {
-            if (layout instanceof ValueLayout valueLayout) {
-                return valueLayout.carrier();
-            } else if (layout instanceof GroupLayout) {
-                return MemorySegment.class;
-            } else {
-                throw new AssertionError("Cannot get here!");
-            }
-        }
-
-        private Object invoke(SegmentAllocator allocator, Object[] args) throws Throwable {
-            // one trailing Object[]
-            int nNamedArgs = function.argumentLayouts().size();
-            assert(args.length == nNamedArgs + 1);
-            // The last argument is the array of vararg collector
-            Object[] unnamedArgs = (Object[]) args[args.length - 1];
-
-            int argsCount = nNamedArgs + unnamedArgs.length;
-            Class<?>[] argTypes = new Class<?>[argsCount];
-            MemoryLayout[] argLayouts = new MemoryLayout[nNamedArgs + unnamedArgs.length];
-
-            int pos = 0;
-            for (pos = 0; pos < nNamedArgs; pos++) {
-                argLayouts[pos] = function.argumentLayouts().get(pos);
-            }
-
-            assert pos == nNamedArgs;
-            for (Object o: unnamedArgs) {
-                argLayouts[pos] = variadicLayout(normalize(o.getClass()));
-                pos++;
-            }
-            assert pos == argsCount;
-
-            FunctionDescriptor f = (function.returnLayout().isEmpty()) ?
-                    FunctionDescriptor.ofVoid(argLayouts) :
-                    FunctionDescriptor.of(function.returnLayout().get(), argLayouts);
-            MethodHandle mh = LINKER.downcallHandle(symbol, f);
-            boolean needsAllocator = function.returnLayout().isPresent() &&
-                                            function.returnLayout().get() instanceof GroupLayout;
-            if (needsAllocator) {
-                mh = mh.bindTo(allocator);
-            }
-            // flatten argument list so that it can be passed to an asSpreader MH
-            Object[] allArgs = new Object[nNamedArgs + unnamedArgs.length];
-            System.arraycopy(args, 0, allArgs, 0, nNamedArgs);
-            System.arraycopy(unnamedArgs, 0, allArgs, nNamedArgs, unnamedArgs.length);
-
-            return mh.asSpreader(Object[].class, argsCount).invoke(allArgs);
-        }
-
-        private static Class<?> unboxIfNeeded(Class<?> clazz) {
-            if (clazz == Boolean.class) {
-                return boolean.class;
-            } else if (clazz == Void.class) {
-                return void.class;
-            } else if (clazz == Byte.class) {
-                return byte.class;
-            } else if (clazz == Character.class) {
-                return char.class;
-            } else if (clazz == Short.class) {
-                return short.class;
-            } else if (clazz == Integer.class) {
-                return int.class;
-            } else if (clazz == Long.class) {
-                return long.class;
-            } else if (clazz == Float.class) {
-                return float.class;
-            } else if (clazz == Double.class) {
-                return double.class;
-            } else {
-                return clazz;
-            }
-        }
-
-        private Class<?> promote(Class<?> c) {
-            if (c == byte.class || c == char.class || c == short.class || c == int.class) {
-                return long.class;
-            } else if (c == float.class) {
-                return double.class;
-            } else {
-                return c;
-            }
-        }
-
-        private Class<?> normalize(Class<?> c) {
-            c = unboxIfNeeded(c);
-            if (c.isPrimitive()) {
-                return promote(c);
-            }
-            if (c == MemorySegment.class) {
-                return MemorySegment.class;
-            }
-            throw new IllegalArgumentException("Invalid type for ABI: " + c.getTypeName());
-        }
-
-        private MemoryLayout variadicLayout(Class<?> c) {
-            if (c == long.class) {
-                return JAVA_LONG;
-            } else if (c == double.class) {
-                return JAVA_DOUBLE;
-            } else if (c == MemorySegment.class) {
-                return ADDRESS;
-            } else {
-                throw new IllegalArgumentException("Unhandled variadic argument class: " + c);
-            }
-        }
-    }
-}
diff --git a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3_lowlevel/constants$0.java b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3_lowlevel/constants$0.java
deleted file mode 100644
index 209311fc..00000000
--- a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3_lowlevel/constants$0.java
+++ /dev/null
@@ -1,34 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.linux.aarch64.extr.fuse3_lowlevel;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$0 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$0() {}
-    static final StructLayout const$0 = MemoryLayout.structLayout(
-        JAVA_INT.withName("singlethread"),
-        JAVA_INT.withName("foreground"),
-        JAVA_INT.withName("debug"),
-        JAVA_INT.withName("nodefault_subtype"),
-        RuntimeHelper.POINTER.withName("mountpoint"),
-        JAVA_INT.withName("show_version"),
-        JAVA_INT.withName("show_help"),
-        JAVA_INT.withName("clone_fd"),
-        JAVA_INT.withName("max_idle_threads"),
-        JAVA_INT.withName("max_threads"),
-        MemoryLayout.paddingLayout(4)
-    ).withName("fuse_cmdline_opts");
-    static final VarHandle const$1 = constants$0.const$0.varHandle(MemoryLayout.PathElement.groupElement("singlethread"));
-    static final VarHandle const$2 = constants$0.const$0.varHandle(MemoryLayout.PathElement.groupElement("foreground"));
-    static final VarHandle const$3 = constants$0.const$0.varHandle(MemoryLayout.PathElement.groupElement("debug"));
-    static final VarHandle const$4 = constants$0.const$0.varHandle(MemoryLayout.PathElement.groupElement("nodefault_subtype"));
-    static final VarHandle const$5 = constants$0.const$0.varHandle(MemoryLayout.PathElement.groupElement("mountpoint"));
-}
-
-
diff --git a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3_lowlevel/constants$1.java b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3_lowlevel/constants$1.java
deleted file mode 100644
index 4060249a..00000000
--- a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3_lowlevel/constants$1.java
+++ /dev/null
@@ -1,21 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.linux.aarch64.extr.fuse3_lowlevel;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$1 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$1() {}
-    static final VarHandle const$0 = constants$0.const$0.varHandle(MemoryLayout.PathElement.groupElement("show_version"));
-    static final VarHandle const$1 = constants$0.const$0.varHandle(MemoryLayout.PathElement.groupElement("show_help"));
-    static final VarHandle const$2 = constants$0.const$0.varHandle(MemoryLayout.PathElement.groupElement("clone_fd"));
-    static final VarHandle const$3 = constants$0.const$0.varHandle(MemoryLayout.PathElement.groupElement("max_idle_threads"));
-    static final VarHandle const$4 = constants$0.const$0.varHandle(MemoryLayout.PathElement.groupElement("max_threads"));
-}
-
-
diff --git a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3_lowlevel/fuse_cmdline_opts.java b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3_lowlevel/fuse_cmdline_opts.java
index 3e30b0c6..2f72fde0 100644
--- a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3_lowlevel/fuse_cmdline_opts.java
+++ b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3_lowlevel/fuse_cmdline_opts.java
@@ -2,308 +2,541 @@
 
 package org.cryptomator.jfuse.linux.aarch64.extr.fuse3_lowlevel;
 
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
+import java.lang.invoke.*;
 import java.lang.foreign.*;
+import java.nio.ByteOrder;
+import java.util.*;
+import java.util.function.*;
+import java.util.stream.*;
+
 import static java.lang.foreign.ValueLayout.*;
+import static java.lang.foreign.MemoryLayout.PathElement.*;
+
 /**
- * {@snippet :
+ * {@snippet lang=c :
  * struct fuse_cmdline_opts {
  *     int singlethread;
  *     int foreground;
  *     int debug;
  *     int nodefault_subtype;
- *     char* mountpoint;
+ *     char *mountpoint;
  *     int show_version;
  *     int show_help;
  *     int clone_fd;
  *     unsigned int max_idle_threads;
  *     unsigned int max_threads;
- * };
+ * }
  * }
  */
 public class fuse_cmdline_opts {
 
-    public static MemoryLayout $LAYOUT() {
-        return constants$0.const$0;
+    fuse_cmdline_opts() {
+        // Should not be called directly
     }
-    public static VarHandle singlethread$VH() {
-        return constants$0.const$1;
+
+    private static final GroupLayout $LAYOUT = MemoryLayout.structLayout(
+        fuse_lowlevel_h.C_INT.withName("singlethread"),
+        fuse_lowlevel_h.C_INT.withName("foreground"),
+        fuse_lowlevel_h.C_INT.withName("debug"),
+        fuse_lowlevel_h.C_INT.withName("nodefault_subtype"),
+        fuse_lowlevel_h.C_POINTER.withName("mountpoint"),
+        fuse_lowlevel_h.C_INT.withName("show_version"),
+        fuse_lowlevel_h.C_INT.withName("show_help"),
+        fuse_lowlevel_h.C_INT.withName("clone_fd"),
+        fuse_lowlevel_h.C_INT.withName("max_idle_threads"),
+        fuse_lowlevel_h.C_INT.withName("max_threads"),
+        MemoryLayout.paddingLayout(4)
+    ).withName("fuse_cmdline_opts");
+
+    /**
+     * The layout of this struct
+     */
+    public static final GroupLayout layout() {
+        return $LAYOUT;
     }
+
+    private static final OfInt singlethread$LAYOUT = (OfInt)$LAYOUT.select(groupElement("singlethread"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int singlethread
+     * }
+     */
+    public static final OfInt singlethread$layout() {
+        return singlethread$LAYOUT;
+    }
+
+    private static final long singlethread$OFFSET = 0;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int singlethread
+     * }
+     */
+    public static final long singlethread$offset() {
+        return singlethread$OFFSET;
+    }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int singlethread;
+     * {@snippet lang=c :
+     * int singlethread
      * }
      */
-    public static int singlethread$get(MemorySegment seg) {
-        return (int)constants$0.const$1.get(seg);
+    public static int singlethread(MemorySegment struct) {
+        return struct.get(singlethread$LAYOUT, singlethread$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int singlethread;
+     * {@snippet lang=c :
+     * int singlethread
      * }
      */
-    public static void singlethread$set(MemorySegment seg, int x) {
-        constants$0.const$1.set(seg, x);
-    }
-    public static int singlethread$get(MemorySegment seg, long index) {
-        return (int)constants$0.const$1.get(seg.asSlice(index*sizeof()));
+    public static void singlethread(MemorySegment struct, int fieldValue) {
+        struct.set(singlethread$LAYOUT, singlethread$OFFSET, fieldValue);
     }
-    public static void singlethread$set(MemorySegment seg, long index, int x) {
-        constants$0.const$1.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt foreground$LAYOUT = (OfInt)$LAYOUT.select(groupElement("foreground"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int foreground
+     * }
+     */
+    public static final OfInt foreground$layout() {
+        return foreground$LAYOUT;
     }
-    public static VarHandle foreground$VH() {
-        return constants$0.const$2;
+
+    private static final long foreground$OFFSET = 4;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int foreground
+     * }
+     */
+    public static final long foreground$offset() {
+        return foreground$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int foreground;
+     * {@snippet lang=c :
+     * int foreground
      * }
      */
-    public static int foreground$get(MemorySegment seg) {
-        return (int)constants$0.const$2.get(seg);
+    public static int foreground(MemorySegment struct) {
+        return struct.get(foreground$LAYOUT, foreground$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int foreground;
+     * {@snippet lang=c :
+     * int foreground
      * }
      */
-    public static void foreground$set(MemorySegment seg, int x) {
-        constants$0.const$2.set(seg, x);
+    public static void foreground(MemorySegment struct, int fieldValue) {
+        struct.set(foreground$LAYOUT, foreground$OFFSET, fieldValue);
     }
-    public static int foreground$get(MemorySegment seg, long index) {
-        return (int)constants$0.const$2.get(seg.asSlice(index*sizeof()));
-    }
-    public static void foreground$set(MemorySegment seg, long index, int x) {
-        constants$0.const$2.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt debug$LAYOUT = (OfInt)$LAYOUT.select(groupElement("debug"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int debug
+     * }
+     */
+    public static final OfInt debug$layout() {
+        return debug$LAYOUT;
     }
-    public static VarHandle debug$VH() {
-        return constants$0.const$3;
+
+    private static final long debug$OFFSET = 8;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int debug
+     * }
+     */
+    public static final long debug$offset() {
+        return debug$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int debug;
+     * {@snippet lang=c :
+     * int debug
      * }
      */
-    public static int debug$get(MemorySegment seg) {
-        return (int)constants$0.const$3.get(seg);
+    public static int debug(MemorySegment struct) {
+        return struct.get(debug$LAYOUT, debug$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int debug;
+     * {@snippet lang=c :
+     * int debug
      * }
      */
-    public static void debug$set(MemorySegment seg, int x) {
-        constants$0.const$3.set(seg, x);
+    public static void debug(MemorySegment struct, int fieldValue) {
+        struct.set(debug$LAYOUT, debug$OFFSET, fieldValue);
     }
-    public static int debug$get(MemorySegment seg, long index) {
-        return (int)constants$0.const$3.get(seg.asSlice(index*sizeof()));
-    }
-    public static void debug$set(MemorySegment seg, long index, int x) {
-        constants$0.const$3.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt nodefault_subtype$LAYOUT = (OfInt)$LAYOUT.select(groupElement("nodefault_subtype"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int nodefault_subtype
+     * }
+     */
+    public static final OfInt nodefault_subtype$layout() {
+        return nodefault_subtype$LAYOUT;
     }
-    public static VarHandle nodefault_subtype$VH() {
-        return constants$0.const$4;
+
+    private static final long nodefault_subtype$OFFSET = 12;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int nodefault_subtype
+     * }
+     */
+    public static final long nodefault_subtype$offset() {
+        return nodefault_subtype$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int nodefault_subtype;
+     * {@snippet lang=c :
+     * int nodefault_subtype
      * }
      */
-    public static int nodefault_subtype$get(MemorySegment seg) {
-        return (int)constants$0.const$4.get(seg);
+    public static int nodefault_subtype(MemorySegment struct) {
+        return struct.get(nodefault_subtype$LAYOUT, nodefault_subtype$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int nodefault_subtype;
+     * {@snippet lang=c :
+     * int nodefault_subtype
      * }
      */
-    public static void nodefault_subtype$set(MemorySegment seg, int x) {
-        constants$0.const$4.set(seg, x);
-    }
-    public static int nodefault_subtype$get(MemorySegment seg, long index) {
-        return (int)constants$0.const$4.get(seg.asSlice(index*sizeof()));
+    public static void nodefault_subtype(MemorySegment struct, int fieldValue) {
+        struct.set(nodefault_subtype$LAYOUT, nodefault_subtype$OFFSET, fieldValue);
     }
-    public static void nodefault_subtype$set(MemorySegment seg, long index, int x) {
-        constants$0.const$4.set(seg.asSlice(index*sizeof()), x);
+
+    private static final AddressLayout mountpoint$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("mountpoint"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * char *mountpoint
+     * }
+     */
+    public static final AddressLayout mountpoint$layout() {
+        return mountpoint$LAYOUT;
     }
-    public static VarHandle mountpoint$VH() {
-        return constants$0.const$5;
+
+    private static final long mountpoint$OFFSET = 16;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * char *mountpoint
+     * }
+     */
+    public static final long mountpoint$offset() {
+        return mountpoint$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * char* mountpoint;
+     * {@snippet lang=c :
+     * char *mountpoint
      * }
      */
-    public static MemorySegment mountpoint$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$0.const$5.get(seg);
+    public static MemorySegment mountpoint(MemorySegment struct) {
+        return struct.get(mountpoint$LAYOUT, mountpoint$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * char* mountpoint;
+     * {@snippet lang=c :
+     * char *mountpoint
      * }
      */
-    public static void mountpoint$set(MemorySegment seg, MemorySegment x) {
-        constants$0.const$5.set(seg, x);
-    }
-    public static MemorySegment mountpoint$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$0.const$5.get(seg.asSlice(index*sizeof()));
+    public static void mountpoint(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(mountpoint$LAYOUT, mountpoint$OFFSET, fieldValue);
     }
-    public static void mountpoint$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$0.const$5.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt show_version$LAYOUT = (OfInt)$LAYOUT.select(groupElement("show_version"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int show_version
+     * }
+     */
+    public static final OfInt show_version$layout() {
+        return show_version$LAYOUT;
     }
-    public static VarHandle show_version$VH() {
-        return constants$1.const$0;
+
+    private static final long show_version$OFFSET = 24;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int show_version
+     * }
+     */
+    public static final long show_version$offset() {
+        return show_version$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int show_version;
+     * {@snippet lang=c :
+     * int show_version
      * }
      */
-    public static int show_version$get(MemorySegment seg) {
-        return (int)constants$1.const$0.get(seg);
+    public static int show_version(MemorySegment struct) {
+        return struct.get(show_version$LAYOUT, show_version$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int show_version;
+     * {@snippet lang=c :
+     * int show_version
      * }
      */
-    public static void show_version$set(MemorySegment seg, int x) {
-        constants$1.const$0.set(seg, x);
-    }
-    public static int show_version$get(MemorySegment seg, long index) {
-        return (int)constants$1.const$0.get(seg.asSlice(index*sizeof()));
+    public static void show_version(MemorySegment struct, int fieldValue) {
+        struct.set(show_version$LAYOUT, show_version$OFFSET, fieldValue);
     }
-    public static void show_version$set(MemorySegment seg, long index, int x) {
-        constants$1.const$0.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt show_help$LAYOUT = (OfInt)$LAYOUT.select(groupElement("show_help"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int show_help
+     * }
+     */
+    public static final OfInt show_help$layout() {
+        return show_help$LAYOUT;
     }
-    public static VarHandle show_help$VH() {
-        return constants$1.const$1;
+
+    private static final long show_help$OFFSET = 28;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int show_help
+     * }
+     */
+    public static final long show_help$offset() {
+        return show_help$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int show_help;
+     * {@snippet lang=c :
+     * int show_help
      * }
      */
-    public static int show_help$get(MemorySegment seg) {
-        return (int)constants$1.const$1.get(seg);
+    public static int show_help(MemorySegment struct) {
+        return struct.get(show_help$LAYOUT, show_help$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int show_help;
+     * {@snippet lang=c :
+     * int show_help
      * }
      */
-    public static void show_help$set(MemorySegment seg, int x) {
-        constants$1.const$1.set(seg, x);
+    public static void show_help(MemorySegment struct, int fieldValue) {
+        struct.set(show_help$LAYOUT, show_help$OFFSET, fieldValue);
     }
-    public static int show_help$get(MemorySegment seg, long index) {
-        return (int)constants$1.const$1.get(seg.asSlice(index*sizeof()));
-    }
-    public static void show_help$set(MemorySegment seg, long index, int x) {
-        constants$1.const$1.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt clone_fd$LAYOUT = (OfInt)$LAYOUT.select(groupElement("clone_fd"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int clone_fd
+     * }
+     */
+    public static final OfInt clone_fd$layout() {
+        return clone_fd$LAYOUT;
     }
-    public static VarHandle clone_fd$VH() {
-        return constants$1.const$2;
+
+    private static final long clone_fd$OFFSET = 32;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int clone_fd
+     * }
+     */
+    public static final long clone_fd$offset() {
+        return clone_fd$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int clone_fd;
+     * {@snippet lang=c :
+     * int clone_fd
      * }
      */
-    public static int clone_fd$get(MemorySegment seg) {
-        return (int)constants$1.const$2.get(seg);
+    public static int clone_fd(MemorySegment struct) {
+        return struct.get(clone_fd$LAYOUT, clone_fd$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int clone_fd;
+     * {@snippet lang=c :
+     * int clone_fd
      * }
      */
-    public static void clone_fd$set(MemorySegment seg, int x) {
-        constants$1.const$2.set(seg, x);
+    public static void clone_fd(MemorySegment struct, int fieldValue) {
+        struct.set(clone_fd$LAYOUT, clone_fd$OFFSET, fieldValue);
     }
-    public static int clone_fd$get(MemorySegment seg, long index) {
-        return (int)constants$1.const$2.get(seg.asSlice(index*sizeof()));
-    }
-    public static void clone_fd$set(MemorySegment seg, long index, int x) {
-        constants$1.const$2.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt max_idle_threads$LAYOUT = (OfInt)$LAYOUT.select(groupElement("max_idle_threads"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * unsigned int max_idle_threads
+     * }
+     */
+    public static final OfInt max_idle_threads$layout() {
+        return max_idle_threads$LAYOUT;
     }
-    public static VarHandle max_idle_threads$VH() {
-        return constants$1.const$3;
+
+    private static final long max_idle_threads$OFFSET = 36;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * unsigned int max_idle_threads
+     * }
+     */
+    public static final long max_idle_threads$offset() {
+        return max_idle_threads$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned int max_idle_threads;
+     * {@snippet lang=c :
+     * unsigned int max_idle_threads
      * }
      */
-    public static int max_idle_threads$get(MemorySegment seg) {
-        return (int)constants$1.const$3.get(seg);
+    public static int max_idle_threads(MemorySegment struct) {
+        return struct.get(max_idle_threads$LAYOUT, max_idle_threads$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned int max_idle_threads;
+     * {@snippet lang=c :
+     * unsigned int max_idle_threads
      * }
      */
-    public static void max_idle_threads$set(MemorySegment seg, int x) {
-        constants$1.const$3.set(seg, x);
-    }
-    public static int max_idle_threads$get(MemorySegment seg, long index) {
-        return (int)constants$1.const$3.get(seg.asSlice(index*sizeof()));
+    public static void max_idle_threads(MemorySegment struct, int fieldValue) {
+        struct.set(max_idle_threads$LAYOUT, max_idle_threads$OFFSET, fieldValue);
     }
-    public static void max_idle_threads$set(MemorySegment seg, long index, int x) {
-        constants$1.const$3.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt max_threads$LAYOUT = (OfInt)$LAYOUT.select(groupElement("max_threads"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * unsigned int max_threads
+     * }
+     */
+    public static final OfInt max_threads$layout() {
+        return max_threads$LAYOUT;
     }
-    public static VarHandle max_threads$VH() {
-        return constants$1.const$4;
+
+    private static final long max_threads$OFFSET = 40;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * unsigned int max_threads
+     * }
+     */
+    public static final long max_threads$offset() {
+        return max_threads$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned int max_threads;
+     * {@snippet lang=c :
+     * unsigned int max_threads
      * }
      */
-    public static int max_threads$get(MemorySegment seg) {
-        return (int)constants$1.const$4.get(seg);
+    public static int max_threads(MemorySegment struct) {
+        return struct.get(max_threads$LAYOUT, max_threads$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned int max_threads;
+     * {@snippet lang=c :
+     * unsigned int max_threads
      * }
      */
-    public static void max_threads$set(MemorySegment seg, int x) {
-        constants$1.const$4.set(seg, x);
+    public static void max_threads(MemorySegment struct, int fieldValue) {
+        struct.set(max_threads$LAYOUT, max_threads$OFFSET, fieldValue);
+    }
+
+    /**
+     * Obtains a slice of {@code arrayParam} which selects the array element at {@code index}.
+     * The returned segment has address {@code arrayParam.address() + index * layout().byteSize()}
+     */
+    public static MemorySegment asSlice(MemorySegment array, long index) {
+        return array.asSlice(layout().byteSize() * index);
+    }
+
+    /**
+     * The size (in bytes) of this struct
+     */
+    public static long sizeof() { return layout().byteSize(); }
+
+    /**
+     * Allocate a segment of size {@code layout().byteSize()} using {@code allocator}
+     */
+    public static MemorySegment allocate(SegmentAllocator allocator) {
+        return allocator.allocate(layout());
     }
-    public static int max_threads$get(MemorySegment seg, long index) {
-        return (int)constants$1.const$4.get(seg.asSlice(index*sizeof()));
+
+    /**
+     * Allocate an array of size {@code elementCount} using {@code allocator}.
+     * The returned segment has size {@code elementCount * layout().byteSize()}.
+     */
+    public static MemorySegment allocateArray(long elementCount, SegmentAllocator allocator) {
+        return allocator.allocate(MemoryLayout.sequenceLayout(elementCount, layout()));
     }
-    public static void max_threads$set(MemorySegment seg, long index, int x) {
-        constants$1.const$4.set(seg.asSlice(index*sizeof()), x);
+
+    /**
+     * Reinterprets {@code addr} using target {@code arena} and {@code cleanupAction) (if any).
+     * The returned segment has size {@code layout().byteSize()}
+     */
+    public static MemorySegment reinterpret(MemorySegment addr, Arena arena, Consumer<MemorySegment> cleanup) {
+        return reinterpret(addr, 1, arena, cleanup);
     }
-    public static long sizeof() { return $LAYOUT().byteSize(); }
-    public static MemorySegment allocate(SegmentAllocator allocator) { return allocator.allocate($LAYOUT()); }
-    public static MemorySegment allocateArray(long len, SegmentAllocator allocator) {
-        return allocator.allocate(MemoryLayout.sequenceLayout(len, $LAYOUT()));
+
+    /**
+     * Reinterprets {@code addr} using target {@code arena} and {@code cleanupAction) (if any).
+     * The returned segment has size {@code elementCount * layout().byteSize()}
+     */
+    public static MemorySegment reinterpret(MemorySegment addr, long elementCount, Arena arena, Consumer<MemorySegment> cleanup) {
+        return addr.reinterpret(layout().byteSize() * elementCount, arena, cleanup);
     }
-    public static MemorySegment ofAddress(MemorySegment addr, Arena scope) { return RuntimeHelper.asArray(addr, $LAYOUT(), 1, scope); }
 }
 
-
diff --git a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3_lowlevel/fuse_lowlevel_h.java b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3_lowlevel/fuse_lowlevel_h.java
index 0d0c510c..31b7100f 100644
--- a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3_lowlevel/fuse_lowlevel_h.java
+++ b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse3_lowlevel/fuse_lowlevel_h.java
@@ -2,21 +2,71 @@
 
 package org.cryptomator.jfuse.linux.aarch64.extr.fuse3_lowlevel;
 
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
+import java.lang.invoke.*;
 import java.lang.foreign.*;
+import java.nio.ByteOrder;
+import java.util.*;
+import java.util.function.*;
+import java.util.stream.*;
+
 import static java.lang.foreign.ValueLayout.*;
-public class fuse_lowlevel_h  {
-
-    public static final OfByte C_CHAR = JAVA_BYTE;
-    public static final OfShort C_SHORT = JAVA_SHORT;
-    public static final OfInt C_INT = JAVA_INT;
-    public static final OfLong C_LONG = JAVA_LONG;
-    public static final OfLong C_LONG_LONG = JAVA_LONG;
-    public static final OfFloat C_FLOAT = JAVA_FLOAT;
-    public static final OfDouble C_DOUBLE = JAVA_DOUBLE;
-    public static final AddressLayout C_POINTER = RuntimeHelper.POINTER;
-}
+import static java.lang.foreign.MemoryLayout.PathElement.*;
+
+public class fuse_lowlevel_h {
+
+    fuse_lowlevel_h() {
+        // Should not be called directly
+    }
+
+    static final Arena LIBRARY_ARENA = Arena.ofAuto();
+    static final boolean TRACE_DOWNCALLS = Boolean.getBoolean("jextract.trace.downcalls");
 
+    static void traceDowncall(String name, Object... args) {
+         String traceArgs = Arrays.stream(args)
+                       .map(Object::toString)
+                       .collect(Collectors.joining(", "));
+         System.out.printf("%s(%s)\n", name, traceArgs);
+    }
+
+    static MemorySegment findOrThrow(String symbol) {
+        return SYMBOL_LOOKUP.find(symbol)
+            .orElseThrow(() -> new UnsatisfiedLinkError("unresolved symbol: " + symbol));
+    }
+
+    static MethodHandle upcallHandle(Class<?> fi, String name, FunctionDescriptor fdesc) {
+        try {
+            return MethodHandles.lookup().findVirtual(fi, name, fdesc.toMethodType());
+        } catch (ReflectiveOperationException ex) {
+            throw new AssertionError(ex);
+        }
+    }
+
+    static MemoryLayout align(MemoryLayout layout, long align) {
+        return switch (layout) {
+            case PaddingLayout p -> p;
+            case ValueLayout v -> v.withByteAlignment(align);
+            case GroupLayout g -> {
+                MemoryLayout[] alignedMembers = g.memberLayouts().stream()
+                        .map(m -> align(m, align)).toArray(MemoryLayout[]::new);
+                yield g instanceof StructLayout ?
+                        MemoryLayout.structLayout(alignedMembers) : MemoryLayout.unionLayout(alignedMembers);
+            }
+            case SequenceLayout s -> MemoryLayout.sequenceLayout(s.elementCount(), align(s.elementLayout(), align));
+        };
+    }
+
+    static final SymbolLookup SYMBOL_LOOKUP = SymbolLookup.loaderLookup()
+            .or(Linker.nativeLinker().defaultLookup());
+
+    public static final ValueLayout.OfBoolean C_BOOL = ValueLayout.JAVA_BOOLEAN;
+    public static final ValueLayout.OfByte C_CHAR = ValueLayout.JAVA_BYTE;
+    public static final ValueLayout.OfShort C_SHORT = ValueLayout.JAVA_SHORT;
+    public static final ValueLayout.OfInt C_INT = ValueLayout.JAVA_INT;
+    public static final ValueLayout.OfLong C_LONG_LONG = ValueLayout.JAVA_LONG;
+    public static final ValueLayout.OfFloat C_FLOAT = ValueLayout.JAVA_FLOAT;
+    public static final ValueLayout.OfDouble C_DOUBLE = ValueLayout.JAVA_DOUBLE;
+    public static final AddressLayout C_POINTER = ValueLayout.ADDRESS
+            .withTargetLayout(MemoryLayout.sequenceLayout(java.lang.Long.MAX_VALUE, JAVA_BYTE));
+    public static final ValueLayout.OfLong C_LONG = ValueLayout.JAVA_LONG;
+}
 
diff --git a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/stat/RuntimeHelper.java b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/stat/RuntimeHelper.java
deleted file mode 100644
index b3d594c2..00000000
--- a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/stat/RuntimeHelper.java
+++ /dev/null
@@ -1,245 +0,0 @@
-package org.cryptomator.jfuse.linux.aarch64.extr.stat;
-// Generated by jextract
-
-import java.lang.foreign.Linker;
-import java.lang.foreign.FunctionDescriptor;
-import java.lang.foreign.GroupLayout;
-import java.lang.foreign.SymbolLookup;
-import java.lang.foreign.MemoryLayout;
-import java.lang.foreign.MemorySegment;
-import java.lang.foreign.Arena;
-import java.lang.foreign.SegmentAllocator;
-import java.lang.foreign.ValueLayout;
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.MethodHandles;
-import java.lang.invoke.MethodType;
-import java.io.File;
-import java.nio.file.Path;
-import java.nio.charset.StandardCharsets;
-import java.util.Arrays;
-import java.util.Optional;
-import java.util.stream.Stream;
-
-import java.lang.foreign.AddressLayout;
-import java.lang.foreign.MemoryLayout;
-
-import static java.lang.foreign.Linker.*;
-import static java.lang.foreign.ValueLayout.*;
-
-final class RuntimeHelper {
-
-    private static final Linker LINKER = Linker.nativeLinker();
-    private static final ClassLoader LOADER = RuntimeHelper.class.getClassLoader();
-    private static final MethodHandles.Lookup MH_LOOKUP = MethodHandles.lookup();
-    private static final SymbolLookup SYMBOL_LOOKUP;
-    private static final SegmentAllocator THROWING_ALLOCATOR = (x, y) -> { throw new AssertionError("should not reach here"); };
-    static final AddressLayout POINTER = ValueLayout.ADDRESS.withTargetLayout(MemoryLayout.sequenceLayout(JAVA_BYTE));
-
-    final static SegmentAllocator CONSTANT_ALLOCATOR =
-            (size, align) -> Arena.ofAuto().allocate(size, align);
-
-    static {
-        
-        SymbolLookup loaderLookup = SymbolLookup.loaderLookup();
-        SYMBOL_LOOKUP = name -> loaderLookup.find(name).or(() -> LINKER.defaultLookup().find(name));
-    }
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private RuntimeHelper() {}
-
-    static <T> T requireNonNull(T obj, String symbolName) {
-        if (obj == null) {
-            throw new UnsatisfiedLinkError("unresolved symbol: " + symbolName);
-        }
-        return obj;
-    }
-
-    static MemorySegment lookupGlobalVariable(String name, MemoryLayout layout) {
-        return SYMBOL_LOOKUP.find(name)
-                .map(s -> s.reinterpret(layout.byteSize()))
-                .orElse(null);
-    }
-
-    static MethodHandle downcallHandle(String name, FunctionDescriptor fdesc) {
-        return SYMBOL_LOOKUP.find(name).
-                map(addr -> LINKER.downcallHandle(addr, fdesc)).
-                orElse(null);
-    }
-
-    static MethodHandle downcallHandle(FunctionDescriptor fdesc) {
-        return LINKER.downcallHandle(fdesc);
-    }
-
-    static MethodHandle downcallHandleVariadic(String name, FunctionDescriptor fdesc) {
-        return SYMBOL_LOOKUP.find(name).
-                map(addr -> VarargsInvoker.make(addr, fdesc)).
-                orElse(null);
-    }
-
-    static MethodHandle upcallHandle(Class<?> fi, String name, FunctionDescriptor fdesc) {
-        try {
-            return MH_LOOKUP.findVirtual(fi, name, fdesc.toMethodType());
-        } catch (Throwable ex) {
-            throw new AssertionError(ex);
-        }
-    }
-
-    static <Z> MemorySegment upcallStub(MethodHandle fiHandle, Z z, FunctionDescriptor fdesc, Arena scope) {
-        try {
-            fiHandle = fiHandle.bindTo(z);
-            return LINKER.upcallStub(fiHandle, fdesc, scope);
-        } catch (Throwable ex) {
-            throw new AssertionError(ex);
-        }
-    }
-
-    static MemorySegment asArray(MemorySegment addr, MemoryLayout layout, int numElements, Arena arena) {
-         return addr.reinterpret(numElements * layout.byteSize(), arena, null);
-    }
-
-    // Internals only below this point
-
-    private static final class VarargsInvoker {
-        private static final MethodHandle INVOKE_MH;
-        private final MemorySegment symbol;
-        private final FunctionDescriptor function;
-
-        private VarargsInvoker(MemorySegment symbol, FunctionDescriptor function) {
-            this.symbol = symbol;
-            this.function = function;
-        }
-
-        static {
-            try {
-                INVOKE_MH = MethodHandles.lookup().findVirtual(VarargsInvoker.class, "invoke", MethodType.methodType(Object.class, SegmentAllocator.class, Object[].class));
-            } catch (ReflectiveOperationException e) {
-                throw new RuntimeException(e);
-            }
-        }
-
-        static MethodHandle make(MemorySegment symbol, FunctionDescriptor function) {
-            VarargsInvoker invoker = new VarargsInvoker(symbol, function);
-            MethodHandle handle = INVOKE_MH.bindTo(invoker).asCollector(Object[].class, function.argumentLayouts().size() + 1);
-            MethodType mtype = MethodType.methodType(function.returnLayout().isPresent() ? carrier(function.returnLayout().get(), true) : void.class);
-            for (MemoryLayout layout : function.argumentLayouts()) {
-                mtype = mtype.appendParameterTypes(carrier(layout, false));
-            }
-            mtype = mtype.appendParameterTypes(Object[].class);
-            boolean needsAllocator = function.returnLayout().isPresent() &&
-                                function.returnLayout().get() instanceof GroupLayout;
-            if (needsAllocator) {
-                mtype = mtype.insertParameterTypes(0, SegmentAllocator.class);
-            } else {
-                handle = MethodHandles.insertArguments(handle, 0, THROWING_ALLOCATOR);
-            }
-            return handle.asType(mtype);
-        }
-
-        static Class<?> carrier(MemoryLayout layout, boolean ret) {
-            if (layout instanceof ValueLayout valueLayout) {
-                return valueLayout.carrier();
-            } else if (layout instanceof GroupLayout) {
-                return MemorySegment.class;
-            } else {
-                throw new AssertionError("Cannot get here!");
-            }
-        }
-
-        private Object invoke(SegmentAllocator allocator, Object[] args) throws Throwable {
-            // one trailing Object[]
-            int nNamedArgs = function.argumentLayouts().size();
-            assert(args.length == nNamedArgs + 1);
-            // The last argument is the array of vararg collector
-            Object[] unnamedArgs = (Object[]) args[args.length - 1];
-
-            int argsCount = nNamedArgs + unnamedArgs.length;
-            Class<?>[] argTypes = new Class<?>[argsCount];
-            MemoryLayout[] argLayouts = new MemoryLayout[nNamedArgs + unnamedArgs.length];
-
-            int pos = 0;
-            for (pos = 0; pos < nNamedArgs; pos++) {
-                argLayouts[pos] = function.argumentLayouts().get(pos);
-            }
-
-            assert pos == nNamedArgs;
-            for (Object o: unnamedArgs) {
-                argLayouts[pos] = variadicLayout(normalize(o.getClass()));
-                pos++;
-            }
-            assert pos == argsCount;
-
-            FunctionDescriptor f = (function.returnLayout().isEmpty()) ?
-                    FunctionDescriptor.ofVoid(argLayouts) :
-                    FunctionDescriptor.of(function.returnLayout().get(), argLayouts);
-            MethodHandle mh = LINKER.downcallHandle(symbol, f);
-            boolean needsAllocator = function.returnLayout().isPresent() &&
-                                            function.returnLayout().get() instanceof GroupLayout;
-            if (needsAllocator) {
-                mh = mh.bindTo(allocator);
-            }
-            // flatten argument list so that it can be passed to an asSpreader MH
-            Object[] allArgs = new Object[nNamedArgs + unnamedArgs.length];
-            System.arraycopy(args, 0, allArgs, 0, nNamedArgs);
-            System.arraycopy(unnamedArgs, 0, allArgs, nNamedArgs, unnamedArgs.length);
-
-            return mh.asSpreader(Object[].class, argsCount).invoke(allArgs);
-        }
-
-        private static Class<?> unboxIfNeeded(Class<?> clazz) {
-            if (clazz == Boolean.class) {
-                return boolean.class;
-            } else if (clazz == Void.class) {
-                return void.class;
-            } else if (clazz == Byte.class) {
-                return byte.class;
-            } else if (clazz == Character.class) {
-                return char.class;
-            } else if (clazz == Short.class) {
-                return short.class;
-            } else if (clazz == Integer.class) {
-                return int.class;
-            } else if (clazz == Long.class) {
-                return long.class;
-            } else if (clazz == Float.class) {
-                return float.class;
-            } else if (clazz == Double.class) {
-                return double.class;
-            } else {
-                return clazz;
-            }
-        }
-
-        private Class<?> promote(Class<?> c) {
-            if (c == byte.class || c == char.class || c == short.class || c == int.class) {
-                return long.class;
-            } else if (c == float.class) {
-                return double.class;
-            } else {
-                return c;
-            }
-        }
-
-        private Class<?> normalize(Class<?> c) {
-            c = unboxIfNeeded(c);
-            if (c.isPrimitive()) {
-                return promote(c);
-            }
-            if (c == MemorySegment.class) {
-                return MemorySegment.class;
-            }
-            throw new IllegalArgumentException("Invalid type for ABI: " + c.getTypeName());
-        }
-
-        private MemoryLayout variadicLayout(Class<?> c) {
-            if (c == long.class) {
-                return JAVA_LONG;
-            } else if (c == double.class) {
-                return JAVA_DOUBLE;
-            } else if (c == MemorySegment.class) {
-                return ADDRESS;
-            } else {
-                throw new IllegalArgumentException("Unhandled variadic argument class: " + c);
-            }
-        }
-    }
-}
diff --git a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/stat/constants$0.java b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/stat/constants$0.java
deleted file mode 100644
index eb233780..00000000
--- a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/stat/constants$0.java
+++ /dev/null
@@ -1,16 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.linux.aarch64.extr.stat;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$0 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$0() {}
-}
-
-
diff --git a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/stat/stat_h.java b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/stat/stat_h.java
index 95891ee4..0111b3b7 100644
--- a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/stat/stat_h.java
+++ b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/stat/stat_h.java
@@ -2,37 +2,89 @@
 
 package org.cryptomator.jfuse.linux.aarch64.extr.stat;
 
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
+import java.lang.invoke.*;
 import java.lang.foreign.*;
+import java.nio.ByteOrder;
+import java.util.*;
+import java.util.function.*;
+import java.util.stream.*;
+
 import static java.lang.foreign.ValueLayout.*;
-public class stat_h  {
-
-    public static final OfByte C_CHAR = JAVA_BYTE;
-    public static final OfShort C_SHORT = JAVA_SHORT;
-    public static final OfInt C_INT = JAVA_INT;
-    public static final OfLong C_LONG = JAVA_LONG;
-    public static final OfLong C_LONG_LONG = JAVA_LONG;
-    public static final OfFloat C_FLOAT = JAVA_FLOAT;
-    public static final OfDouble C_DOUBLE = JAVA_DOUBLE;
-    public static final AddressLayout C_POINTER = RuntimeHelper.POINTER;
+import static java.lang.foreign.MemoryLayout.PathElement.*;
+
+public class stat_h {
+
+    stat_h() {
+        // Should not be called directly
+    }
+
+    static final Arena LIBRARY_ARENA = Arena.ofAuto();
+    static final boolean TRACE_DOWNCALLS = Boolean.getBoolean("jextract.trace.downcalls");
+
+    static void traceDowncall(String name, Object... args) {
+         String traceArgs = Arrays.stream(args)
+                       .map(Object::toString)
+                       .collect(Collectors.joining(", "));
+         System.out.printf("%s(%s)\n", name, traceArgs);
+    }
+
+    static MemorySegment findOrThrow(String symbol) {
+        return SYMBOL_LOOKUP.find(symbol)
+            .orElseThrow(() -> new UnsatisfiedLinkError("unresolved symbol: " + symbol));
+    }
+
+    static MethodHandle upcallHandle(Class<?> fi, String name, FunctionDescriptor fdesc) {
+        try {
+            return MethodHandles.lookup().findVirtual(fi, name, fdesc.toMethodType());
+        } catch (ReflectiveOperationException ex) {
+            throw new AssertionError(ex);
+        }
+    }
+
+    static MemoryLayout align(MemoryLayout layout, long align) {
+        return switch (layout) {
+            case PaddingLayout p -> p;
+            case ValueLayout v -> v.withByteAlignment(align);
+            case GroupLayout g -> {
+                MemoryLayout[] alignedMembers = g.memberLayouts().stream()
+                        .map(m -> align(m, align)).toArray(MemoryLayout[]::new);
+                yield g instanceof StructLayout ?
+                        MemoryLayout.structLayout(alignedMembers) : MemoryLayout.unionLayout(alignedMembers);
+            }
+            case SequenceLayout s -> MemoryLayout.sequenceLayout(s.elementCount(), align(s.elementLayout(), align));
+        };
+    }
+
+    static final SymbolLookup SYMBOL_LOOKUP = SymbolLookup.loaderLookup()
+            .or(Linker.nativeLinker().defaultLookup());
+
+    public static final ValueLayout.OfBoolean C_BOOL = ValueLayout.JAVA_BOOLEAN;
+    public static final ValueLayout.OfByte C_CHAR = ValueLayout.JAVA_BYTE;
+    public static final ValueLayout.OfShort C_SHORT = ValueLayout.JAVA_SHORT;
+    public static final ValueLayout.OfInt C_INT = ValueLayout.JAVA_INT;
+    public static final ValueLayout.OfLong C_LONG_LONG = ValueLayout.JAVA_LONG;
+    public static final ValueLayout.OfFloat C_FLOAT = ValueLayout.JAVA_FLOAT;
+    public static final ValueLayout.OfDouble C_DOUBLE = ValueLayout.JAVA_DOUBLE;
+    public static final AddressLayout C_POINTER = ValueLayout.ADDRESS
+            .withTargetLayout(MemoryLayout.sequenceLayout(java.lang.Long.MAX_VALUE, JAVA_BYTE));
+    public static final ValueLayout.OfLong C_LONG = ValueLayout.JAVA_LONG;
+    private static final long UTIME_NOW = 1073741823L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define UTIME_NOW 1073741823
      * }
      */
     public static long UTIME_NOW() {
-        return 1073741823L;
+        return UTIME_NOW;
     }
+    private static final long UTIME_OMIT = 1073741822L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define UTIME_OMIT 1073741822
      * }
      */
     public static long UTIME_OMIT() {
-        return 1073741822L;
+        return UTIME_OMIT;
     }
 }
 
-
diff --git a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/stdio/RuntimeHelper.java b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/stdio/RuntimeHelper.java
deleted file mode 100644
index 9ff06ef0..00000000
--- a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/stdio/RuntimeHelper.java
+++ /dev/null
@@ -1,245 +0,0 @@
-package org.cryptomator.jfuse.linux.aarch64.extr.stdio;
-// Generated by jextract
-
-import java.lang.foreign.Linker;
-import java.lang.foreign.FunctionDescriptor;
-import java.lang.foreign.GroupLayout;
-import java.lang.foreign.SymbolLookup;
-import java.lang.foreign.MemoryLayout;
-import java.lang.foreign.MemorySegment;
-import java.lang.foreign.Arena;
-import java.lang.foreign.SegmentAllocator;
-import java.lang.foreign.ValueLayout;
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.MethodHandles;
-import java.lang.invoke.MethodType;
-import java.io.File;
-import java.nio.file.Path;
-import java.nio.charset.StandardCharsets;
-import java.util.Arrays;
-import java.util.Optional;
-import java.util.stream.Stream;
-
-import java.lang.foreign.AddressLayout;
-import java.lang.foreign.MemoryLayout;
-
-import static java.lang.foreign.Linker.*;
-import static java.lang.foreign.ValueLayout.*;
-
-final class RuntimeHelper {
-
-    private static final Linker LINKER = Linker.nativeLinker();
-    private static final ClassLoader LOADER = RuntimeHelper.class.getClassLoader();
-    private static final MethodHandles.Lookup MH_LOOKUP = MethodHandles.lookup();
-    private static final SymbolLookup SYMBOL_LOOKUP;
-    private static final SegmentAllocator THROWING_ALLOCATOR = (x, y) -> { throw new AssertionError("should not reach here"); };
-    static final AddressLayout POINTER = ValueLayout.ADDRESS.withTargetLayout(MemoryLayout.sequenceLayout(JAVA_BYTE));
-
-    final static SegmentAllocator CONSTANT_ALLOCATOR =
-            (size, align) -> Arena.ofAuto().allocate(size, align);
-
-    static {
-        
-        SymbolLookup loaderLookup = SymbolLookup.loaderLookup();
-        SYMBOL_LOOKUP = name -> loaderLookup.find(name).or(() -> LINKER.defaultLookup().find(name));
-    }
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private RuntimeHelper() {}
-
-    static <T> T requireNonNull(T obj, String symbolName) {
-        if (obj == null) {
-            throw new UnsatisfiedLinkError("unresolved symbol: " + symbolName);
-        }
-        return obj;
-    }
-
-    static MemorySegment lookupGlobalVariable(String name, MemoryLayout layout) {
-        return SYMBOL_LOOKUP.find(name)
-                .map(s -> s.reinterpret(layout.byteSize()))
-                .orElse(null);
-    }
-
-    static MethodHandle downcallHandle(String name, FunctionDescriptor fdesc) {
-        return SYMBOL_LOOKUP.find(name).
-                map(addr -> LINKER.downcallHandle(addr, fdesc)).
-                orElse(null);
-    }
-
-    static MethodHandle downcallHandle(FunctionDescriptor fdesc) {
-        return LINKER.downcallHandle(fdesc);
-    }
-
-    static MethodHandle downcallHandleVariadic(String name, FunctionDescriptor fdesc) {
-        return SYMBOL_LOOKUP.find(name).
-                map(addr -> VarargsInvoker.make(addr, fdesc)).
-                orElse(null);
-    }
-
-    static MethodHandle upcallHandle(Class<?> fi, String name, FunctionDescriptor fdesc) {
-        try {
-            return MH_LOOKUP.findVirtual(fi, name, fdesc.toMethodType());
-        } catch (Throwable ex) {
-            throw new AssertionError(ex);
-        }
-    }
-
-    static <Z> MemorySegment upcallStub(MethodHandle fiHandle, Z z, FunctionDescriptor fdesc, Arena scope) {
-        try {
-            fiHandle = fiHandle.bindTo(z);
-            return LINKER.upcallStub(fiHandle, fdesc, scope);
-        } catch (Throwable ex) {
-            throw new AssertionError(ex);
-        }
-    }
-
-    static MemorySegment asArray(MemorySegment addr, MemoryLayout layout, int numElements, Arena arena) {
-         return addr.reinterpret(numElements * layout.byteSize(), arena, null);
-    }
-
-    // Internals only below this point
-
-    private static final class VarargsInvoker {
-        private static final MethodHandle INVOKE_MH;
-        private final MemorySegment symbol;
-        private final FunctionDescriptor function;
-
-        private VarargsInvoker(MemorySegment symbol, FunctionDescriptor function) {
-            this.symbol = symbol;
-            this.function = function;
-        }
-
-        static {
-            try {
-                INVOKE_MH = MethodHandles.lookup().findVirtual(VarargsInvoker.class, "invoke", MethodType.methodType(Object.class, SegmentAllocator.class, Object[].class));
-            } catch (ReflectiveOperationException e) {
-                throw new RuntimeException(e);
-            }
-        }
-
-        static MethodHandle make(MemorySegment symbol, FunctionDescriptor function) {
-            VarargsInvoker invoker = new VarargsInvoker(symbol, function);
-            MethodHandle handle = INVOKE_MH.bindTo(invoker).asCollector(Object[].class, function.argumentLayouts().size() + 1);
-            MethodType mtype = MethodType.methodType(function.returnLayout().isPresent() ? carrier(function.returnLayout().get(), true) : void.class);
-            for (MemoryLayout layout : function.argumentLayouts()) {
-                mtype = mtype.appendParameterTypes(carrier(layout, false));
-            }
-            mtype = mtype.appendParameterTypes(Object[].class);
-            boolean needsAllocator = function.returnLayout().isPresent() &&
-                                function.returnLayout().get() instanceof GroupLayout;
-            if (needsAllocator) {
-                mtype = mtype.insertParameterTypes(0, SegmentAllocator.class);
-            } else {
-                handle = MethodHandles.insertArguments(handle, 0, THROWING_ALLOCATOR);
-            }
-            return handle.asType(mtype);
-        }
-
-        static Class<?> carrier(MemoryLayout layout, boolean ret) {
-            if (layout instanceof ValueLayout valueLayout) {
-                return valueLayout.carrier();
-            } else if (layout instanceof GroupLayout) {
-                return MemorySegment.class;
-            } else {
-                throw new AssertionError("Cannot get here!");
-            }
-        }
-
-        private Object invoke(SegmentAllocator allocator, Object[] args) throws Throwable {
-            // one trailing Object[]
-            int nNamedArgs = function.argumentLayouts().size();
-            assert(args.length == nNamedArgs + 1);
-            // The last argument is the array of vararg collector
-            Object[] unnamedArgs = (Object[]) args[args.length - 1];
-
-            int argsCount = nNamedArgs + unnamedArgs.length;
-            Class<?>[] argTypes = new Class<?>[argsCount];
-            MemoryLayout[] argLayouts = new MemoryLayout[nNamedArgs + unnamedArgs.length];
-
-            int pos = 0;
-            for (pos = 0; pos < nNamedArgs; pos++) {
-                argLayouts[pos] = function.argumentLayouts().get(pos);
-            }
-
-            assert pos == nNamedArgs;
-            for (Object o: unnamedArgs) {
-                argLayouts[pos] = variadicLayout(normalize(o.getClass()));
-                pos++;
-            }
-            assert pos == argsCount;
-
-            FunctionDescriptor f = (function.returnLayout().isEmpty()) ?
-                    FunctionDescriptor.ofVoid(argLayouts) :
-                    FunctionDescriptor.of(function.returnLayout().get(), argLayouts);
-            MethodHandle mh = LINKER.downcallHandle(symbol, f);
-            boolean needsAllocator = function.returnLayout().isPresent() &&
-                                            function.returnLayout().get() instanceof GroupLayout;
-            if (needsAllocator) {
-                mh = mh.bindTo(allocator);
-            }
-            // flatten argument list so that it can be passed to an asSpreader MH
-            Object[] allArgs = new Object[nNamedArgs + unnamedArgs.length];
-            System.arraycopy(args, 0, allArgs, 0, nNamedArgs);
-            System.arraycopy(unnamedArgs, 0, allArgs, nNamedArgs, unnamedArgs.length);
-
-            return mh.asSpreader(Object[].class, argsCount).invoke(allArgs);
-        }
-
-        private static Class<?> unboxIfNeeded(Class<?> clazz) {
-            if (clazz == Boolean.class) {
-                return boolean.class;
-            } else if (clazz == Void.class) {
-                return void.class;
-            } else if (clazz == Byte.class) {
-                return byte.class;
-            } else if (clazz == Character.class) {
-                return char.class;
-            } else if (clazz == Short.class) {
-                return short.class;
-            } else if (clazz == Integer.class) {
-                return int.class;
-            } else if (clazz == Long.class) {
-                return long.class;
-            } else if (clazz == Float.class) {
-                return float.class;
-            } else if (clazz == Double.class) {
-                return double.class;
-            } else {
-                return clazz;
-            }
-        }
-
-        private Class<?> promote(Class<?> c) {
-            if (c == byte.class || c == char.class || c == short.class || c == int.class) {
-                return long.class;
-            } else if (c == float.class) {
-                return double.class;
-            } else {
-                return c;
-            }
-        }
-
-        private Class<?> normalize(Class<?> c) {
-            c = unboxIfNeeded(c);
-            if (c.isPrimitive()) {
-                return promote(c);
-            }
-            if (c == MemorySegment.class) {
-                return MemorySegment.class;
-            }
-            throw new IllegalArgumentException("Invalid type for ABI: " + c.getTypeName());
-        }
-
-        private MemoryLayout variadicLayout(Class<?> c) {
-            if (c == long.class) {
-                return JAVA_LONG;
-            } else if (c == double.class) {
-                return JAVA_DOUBLE;
-            } else if (c == MemorySegment.class) {
-                return ADDRESS;
-            } else {
-                throw new IllegalArgumentException("Unhandled variadic argument class: " + c);
-            }
-        }
-    }
-}
diff --git a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/stdio/constants$0.java b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/stdio/constants$0.java
deleted file mode 100644
index 94f9f592..00000000
--- a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/stdio/constants$0.java
+++ /dev/null
@@ -1,16 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.linux.aarch64.extr.stdio;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$0 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$0() {}
-}
-
-
diff --git a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/stdio/stdio_h.java b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/stdio/stdio_h.java
index 31b44a8b..b5530465 100644
--- a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/stdio/stdio_h.java
+++ b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/stdio/stdio_h.java
@@ -2,45 +2,98 @@
 
 package org.cryptomator.jfuse.linux.aarch64.extr.stdio;
 
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
+import java.lang.invoke.*;
 import java.lang.foreign.*;
+import java.nio.ByteOrder;
+import java.util.*;
+import java.util.function.*;
+import java.util.stream.*;
+
 import static java.lang.foreign.ValueLayout.*;
-public class stdio_h  {
-
-    public static final OfByte C_CHAR = JAVA_BYTE;
-    public static final OfShort C_SHORT = JAVA_SHORT;
-    public static final OfInt C_INT = JAVA_INT;
-    public static final OfLong C_LONG = JAVA_LONG;
-    public static final OfLong C_LONG_LONG = JAVA_LONG;
-    public static final OfFloat C_FLOAT = JAVA_FLOAT;
-    public static final OfDouble C_DOUBLE = JAVA_DOUBLE;
-    public static final AddressLayout C_POINTER = RuntimeHelper.POINTER;
+import static java.lang.foreign.MemoryLayout.PathElement.*;
+
+public class stdio_h {
+
+    stdio_h() {
+        // Should not be called directly
+    }
+
+    static final Arena LIBRARY_ARENA = Arena.ofAuto();
+    static final boolean TRACE_DOWNCALLS = Boolean.getBoolean("jextract.trace.downcalls");
+
+    static void traceDowncall(String name, Object... args) {
+         String traceArgs = Arrays.stream(args)
+                       .map(Object::toString)
+                       .collect(Collectors.joining(", "));
+         System.out.printf("%s(%s)\n", name, traceArgs);
+    }
+
+    static MemorySegment findOrThrow(String symbol) {
+        return SYMBOL_LOOKUP.find(symbol)
+            .orElseThrow(() -> new UnsatisfiedLinkError("unresolved symbol: " + symbol));
+    }
+
+    static MethodHandle upcallHandle(Class<?> fi, String name, FunctionDescriptor fdesc) {
+        try {
+            return MethodHandles.lookup().findVirtual(fi, name, fdesc.toMethodType());
+        } catch (ReflectiveOperationException ex) {
+            throw new AssertionError(ex);
+        }
+    }
+
+    static MemoryLayout align(MemoryLayout layout, long align) {
+        return switch (layout) {
+            case PaddingLayout p -> p;
+            case ValueLayout v -> v.withByteAlignment(align);
+            case GroupLayout g -> {
+                MemoryLayout[] alignedMembers = g.memberLayouts().stream()
+                        .map(m -> align(m, align)).toArray(MemoryLayout[]::new);
+                yield g instanceof StructLayout ?
+                        MemoryLayout.structLayout(alignedMembers) : MemoryLayout.unionLayout(alignedMembers);
+            }
+            case SequenceLayout s -> MemoryLayout.sequenceLayout(s.elementCount(), align(s.elementLayout(), align));
+        };
+    }
+
+    static final SymbolLookup SYMBOL_LOOKUP = SymbolLookup.loaderLookup()
+            .or(Linker.nativeLinker().defaultLookup());
+
+    public static final ValueLayout.OfBoolean C_BOOL = ValueLayout.JAVA_BOOLEAN;
+    public static final ValueLayout.OfByte C_CHAR = ValueLayout.JAVA_BYTE;
+    public static final ValueLayout.OfShort C_SHORT = ValueLayout.JAVA_SHORT;
+    public static final ValueLayout.OfInt C_INT = ValueLayout.JAVA_INT;
+    public static final ValueLayout.OfLong C_LONG_LONG = ValueLayout.JAVA_LONG;
+    public static final ValueLayout.OfFloat C_FLOAT = ValueLayout.JAVA_FLOAT;
+    public static final ValueLayout.OfDouble C_DOUBLE = ValueLayout.JAVA_DOUBLE;
+    public static final AddressLayout C_POINTER = ValueLayout.ADDRESS
+            .withTargetLayout(MemoryLayout.sequenceLayout(java.lang.Long.MAX_VALUE, JAVA_BYTE));
+    public static final ValueLayout.OfLong C_LONG = ValueLayout.JAVA_LONG;
+    private static final int RENAME_NOREPLACE = (int)1L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define RENAME_NOREPLACE 1
      * }
      */
     public static int RENAME_NOREPLACE() {
-        return (int)1L;
+        return RENAME_NOREPLACE;
     }
+    private static final int RENAME_EXCHANGE = (int)2L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define RENAME_EXCHANGE 2
      * }
      */
     public static int RENAME_EXCHANGE() {
-        return (int)2L;
+        return RENAME_EXCHANGE;
     }
+    private static final int RENAME_WHITEOUT = (int)4L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define RENAME_WHITEOUT 4
      * }
      */
     public static int RENAME_WHITEOUT() {
-        return (int)4L;
+        return RENAME_WHITEOUT;
     }
 }
 
-
diff --git a/jfuse-linux-aarch64/src/test/java/org/cryptomator/jfuse/linux/aarch64/FileInfoImplTest.java b/jfuse-linux-aarch64/src/test/java/org/cryptomator/jfuse/linux/aarch64/FileInfoImplTest.java
index 6a465a61..05fb57ad 100644
--- a/jfuse-linux-aarch64/src/test/java/org/cryptomator/jfuse/linux/aarch64/FileInfoImplTest.java
+++ b/jfuse-linux-aarch64/src/test/java/org/cryptomator/jfuse/linux/aarch64/FileInfoImplTest.java
@@ -22,7 +22,7 @@ public class FileInfoImplTest {
 	public void testGetOpenFlags(int flags, Set<OpenOption> expectedResult) {
 		try (var arena = Arena.ofConfined()) {
 			var fi = new FileInfoImpl(fuse_file_info.allocate(arena));
-			fuse_file_info.flags$set(fi.segment(), flags);
+			fuse_file_info.flags(fi.segment(), flags);
 
 			var result = fi.getOpenFlags();
 
diff --git a/jfuse-linux-aarch64/src/test/java/org/cryptomator/jfuse/linux/aarch64/FuseConfigImplTest.java b/jfuse-linux-aarch64/src/test/java/org/cryptomator/jfuse/linux/aarch64/FuseConfigImplTest.java
index 841ea8b0..0f7f52f6 100644
--- a/jfuse-linux-aarch64/src/test/java/org/cryptomator/jfuse/linux/aarch64/FuseConfigImplTest.java
+++ b/jfuse-linux-aarch64/src/test/java/org/cryptomator/jfuse/linux/aarch64/FuseConfigImplTest.java
@@ -23,7 +23,7 @@ public class FuseConfigImplTest {
 	public void testGetters(SetInMemorySegment<Number> setter, GetInFuseConfig<Number> getter, Number value) {
 		try (var arena = Arena.ofConfined()) {
 			var segment = fuse_config.allocate(arena);
-			var fuseConfig = new FuseConfigImpl(segment, arena);
+			var fuseConfig = new FuseConfigImpl(segment);
 
 			setter.accept(segment, value);
 
@@ -33,28 +33,28 @@ public void testGetters(SetInMemorySegment<Number> setter, GetInFuseConfig<Numbe
 
 	public static Stream<Arguments> testGetters() {
 		return Stream.of(
-				Arguments.arguments((SetInMemorySegment<Integer>) fuse_config::set_gid$set, Named.of("setGid()", (GetInFuseConfig<Integer>) FuseConfig::setGid), 42),
-				Arguments.arguments((SetInMemorySegment<Integer>) fuse_config::gid$set, Named.of("gid()", (GetInFuseConfig<Integer>) FuseConfig::gid), 42),
-				Arguments.arguments((SetInMemorySegment<Integer>) fuse_config::set_uid$set, Named.of("setUid()", (GetInFuseConfig<Integer>) FuseConfig::setUid), 42),
-				Arguments.arguments((SetInMemorySegment<Integer>) fuse_config::uid$set, Named.of("uid()", (GetInFuseConfig<Integer>) FuseConfig::uid), 42),
-				Arguments.arguments((SetInMemorySegment<Integer>) fuse_config::set_mode$set, Named.of("setMode()", (GetInFuseConfig<Integer>) FuseConfig::setMode), 42),
-				Arguments.arguments((SetInMemorySegment<Integer>) fuse_config::umask$set, Named.of("umask()", (GetInFuseConfig<Integer>) FuseConfig::umask), 42),
-				Arguments.arguments((SetInMemorySegment<Double>) fuse_config::entry_timeout$set, Named.of("entryTimeout()", (GetInFuseConfig<Double>) FuseConfig::entryTimeout), 4.2),
-				Arguments.arguments((SetInMemorySegment<Double>) fuse_config::negative_timeout$set, Named.of("negativeTimeout()", (GetInFuseConfig<Double>) FuseConfig::negativeTimeout), 4.2),
-				Arguments.arguments((SetInMemorySegment<Double>) fuse_config::attr_timeout$set, Named.of("attrTimeout()", (GetInFuseConfig<Double>) FuseConfig::attrTimeout), 4.2),
-				Arguments.arguments((SetInMemorySegment<Integer>) fuse_config::intr$set, Named.of("intr()", (GetInFuseConfig<Integer>) FuseConfig::intr), 42),
-				Arguments.arguments((SetInMemorySegment<Integer>) fuse_config::intr_signal$set, Named.of("intrSignal()", (GetInFuseConfig<Integer>) FuseConfig::intrSignal), 42),
-				Arguments.arguments((SetInMemorySegment<Integer>) fuse_config::remember$set, Named.of("remember()", (GetInFuseConfig<Integer>) FuseConfig::remember), 42),
-				Arguments.arguments((SetInMemorySegment<Integer>) fuse_config::hard_remove$set, Named.of("hardRemove()", (GetInFuseConfig<Integer>) FuseConfig::hardRemove), 42),
-				Arguments.arguments((SetInMemorySegment<Integer>) fuse_config::use_ino$set, Named.of("useIno()", (GetInFuseConfig<Integer>) FuseConfig::useIno), 42),
-				Arguments.arguments((SetInMemorySegment<Integer>) fuse_config::readdir_ino$set, Named.of("readdirIno()", (GetInFuseConfig<Integer>) FuseConfig::readdirIno), 42),
-				Arguments.arguments((SetInMemorySegment<Integer>) fuse_config::direct_io$set, Named.of("directIo()", (GetInFuseConfig<Integer>) FuseConfig::directIo), 42),
-				Arguments.arguments((SetInMemorySegment<Integer>) fuse_config::kernel_cache$set, Named.of("kernelCache()", (GetInFuseConfig<Integer>) FuseConfig::kernelCache), 42),
-				Arguments.arguments((SetInMemorySegment<Integer>) fuse_config::auto_cache$set, Named.of("autoCache()", (GetInFuseConfig<Integer>) FuseConfig::autoCache), 42),
-				Arguments.arguments((SetInMemorySegment<Integer>) fuse_config::ac_attr_timeout_set$set, Named.of("acAtrrTimeoutSet()", (GetInFuseConfig<Integer>) FuseConfig::acAttrTimeoutSet), 42),
-				Arguments.arguments((SetInMemorySegment<Double>) fuse_config::ac_attr_timeout$set, Named.of("acAttrTimeout()", (GetInFuseConfig<Double>) FuseConfig::acAttrTimeout), 4.2),
-				Arguments.arguments((SetInMemorySegment<Integer>) fuse_config::nullpath_ok$set, Named.of("nullpathOk()", (GetInFuseConfig<Integer>) FuseConfig::nullpathOk), 42),
-				Arguments.arguments((SetInMemorySegment<Integer>) fuse_config::no_rofd_flush$set, Named.of("noRofdFlush()", (GetInFuseConfig<Integer>) FuseConfig::noRofdFlush), 42)
+				Arguments.arguments((SetInMemorySegment<Integer>) fuse_config::set_gid, Named.of("setGid()", (GetInFuseConfig<Integer>) FuseConfig::setGid), 42),
+				Arguments.arguments((SetInMemorySegment<Integer>) fuse_config::gid, Named.of("gid()", (GetInFuseConfig<Integer>) FuseConfig::gid), 42),
+				Arguments.arguments((SetInMemorySegment<Integer>) fuse_config::set_uid, Named.of("setUid()", (GetInFuseConfig<Integer>) FuseConfig::setUid), 42),
+				Arguments.arguments((SetInMemorySegment<Integer>) fuse_config::uid, Named.of("uid()", (GetInFuseConfig<Integer>) FuseConfig::uid), 42),
+				Arguments.arguments((SetInMemorySegment<Integer>) fuse_config::set_mode, Named.of("setMode()", (GetInFuseConfig<Integer>) FuseConfig::setMode), 42),
+				Arguments.arguments((SetInMemorySegment<Integer>) fuse_config::umask, Named.of("umask()", (GetInFuseConfig<Integer>) FuseConfig::umask), 42),
+				Arguments.arguments((SetInMemorySegment<Double>) fuse_config::entry_timeout, Named.of("entryTimeout()", (GetInFuseConfig<Double>) FuseConfig::entryTimeout), 4.2),
+				Arguments.arguments((SetInMemorySegment<Double>) fuse_config::negative_timeout, Named.of("negativeTimeout()", (GetInFuseConfig<Double>) FuseConfig::negativeTimeout), 4.2),
+				Arguments.arguments((SetInMemorySegment<Double>) fuse_config::attr_timeout, Named.of("attrTimeout()", (GetInFuseConfig<Double>) FuseConfig::attrTimeout), 4.2),
+				Arguments.arguments((SetInMemorySegment<Integer>) fuse_config::intr, Named.of("intr()", (GetInFuseConfig<Integer>) FuseConfig::intr), 42),
+				Arguments.arguments((SetInMemorySegment<Integer>) fuse_config::intr_signal, Named.of("intrSignal()", (GetInFuseConfig<Integer>) FuseConfig::intrSignal), 42),
+				Arguments.arguments((SetInMemorySegment<Integer>) fuse_config::remember, Named.of("remember()", (GetInFuseConfig<Integer>) FuseConfig::remember), 42),
+				Arguments.arguments((SetInMemorySegment<Integer>) fuse_config::hard_remove, Named.of("hardRemove()", (GetInFuseConfig<Integer>) FuseConfig::hardRemove), 42),
+				Arguments.arguments((SetInMemorySegment<Integer>) fuse_config::use_ino, Named.of("useIno()", (GetInFuseConfig<Integer>) FuseConfig::useIno), 42),
+				Arguments.arguments((SetInMemorySegment<Integer>) fuse_config::readdir_ino, Named.of("readdirIno()", (GetInFuseConfig<Integer>) FuseConfig::readdirIno), 42),
+				Arguments.arguments((SetInMemorySegment<Integer>) fuse_config::direct_io, Named.of("directIo()", (GetInFuseConfig<Integer>) FuseConfig::directIo), 42),
+				Arguments.arguments((SetInMemorySegment<Integer>) fuse_config::kernel_cache, Named.of("kernelCache()", (GetInFuseConfig<Integer>) FuseConfig::kernelCache), 42),
+				Arguments.arguments((SetInMemorySegment<Integer>) fuse_config::auto_cache, Named.of("autoCache()", (GetInFuseConfig<Integer>) FuseConfig::autoCache), 42),
+				Arguments.arguments((SetInMemorySegment<Integer>) fuse_config::ac_attr_timeout_set, Named.of("acAtrrTimeoutSet()", (GetInFuseConfig<Integer>) FuseConfig::acAttrTimeoutSet), 42),
+				Arguments.arguments((SetInMemorySegment<Double>) fuse_config::ac_attr_timeout, Named.of("acAttrTimeout()", (GetInFuseConfig<Double>) FuseConfig::acAttrTimeout), 4.2),
+				Arguments.arguments((SetInMemorySegment<Integer>) fuse_config::nullpath_ok, Named.of("nullpathOk()", (GetInFuseConfig<Integer>) FuseConfig::nullpathOk), 42),
+				Arguments.arguments((SetInMemorySegment<Integer>) fuse_config::no_rofd_flush, Named.of("noRofdFlush()", (GetInFuseConfig<Integer>) FuseConfig::noRofdFlush), 42)
 		);
 	}
 
diff --git a/jfuse-linux-aarch64/src/test/java/org/cryptomator/jfuse/linux/aarch64/FuseConnInfoImplTest.java b/jfuse-linux-aarch64/src/test/java/org/cryptomator/jfuse/linux/aarch64/FuseConnInfoImplTest.java
index c1b72fd4..e0733c39 100644
--- a/jfuse-linux-aarch64/src/test/java/org/cryptomator/jfuse/linux/aarch64/FuseConnInfoImplTest.java
+++ b/jfuse-linux-aarch64/src/test/java/org/cryptomator/jfuse/linux/aarch64/FuseConnInfoImplTest.java
@@ -23,7 +23,7 @@ public class FuseConnInfoImplTest {
 	public void testGetters(SetInMemorySegment setter, GetInConnInfo getter) {
 		try (var arena = Arena.ofConfined()) {
 			var segment = fuse_conn_info.allocate(arena);
-			var connInfo = new FuseConnInfoImpl(segment, arena);
+			var connInfo = new FuseConnInfoImpl(segment);
 
 			setter.accept(segment, 42);
 
@@ -33,16 +33,16 @@ public void testGetters(SetInMemorySegment setter, GetInConnInfo getter) {
 
 	public static Stream<Arguments> testGetters() {
 		return Stream.of(
-				Arguments.arguments((SetInMemorySegment) fuse_conn_info::proto_major$set, Named.of("protoMajor()", (GetInConnInfo) FuseConnInfo::protoMajor)),
-				Arguments.arguments((SetInMemorySegment) fuse_conn_info::proto_minor$set, Named.of("protoMinor()", (GetInConnInfo) FuseConnInfo::protoMinor)),
-				Arguments.arguments((SetInMemorySegment) fuse_conn_info::capable$set, Named.of("capable()", (GetInConnInfo) FuseConnInfo::capable)),
-				Arguments.arguments((SetInMemorySegment) fuse_conn_info::max_write$set, Named.of("maxWrite()", (GetInConnInfo) FuseConnInfo::maxWrite)),
-				Arguments.arguments((SetInMemorySegment) fuse_conn_info::max_read$set, Named.of("maxRead()", (GetInConnInfo) FuseConnInfo::maxRead)),
-				Arguments.arguments((SetInMemorySegment) fuse_conn_info::max_readahead$set, Named.of("maxReadahead()", (GetInConnInfo) FuseConnInfo::maxReadahead)),
-				Arguments.arguments((SetInMemorySegment) fuse_conn_info::max_background$set, Named.of("maxBackground()", (GetInConnInfo) FuseConnInfo::maxBackground)),
-				Arguments.arguments((SetInMemorySegment) fuse_conn_info::congestion_threshold$set, Named.of("congestionThreshold()", (GetInConnInfo) FuseConnInfo::congestionThreshold)),
-				Arguments.arguments((SetInMemorySegment) fuse_conn_info::time_gran$set, Named.of("timeGran()", (GetInConnInfo) FuseConnInfo::timeGran)),
-				Arguments.arguments((SetInMemorySegment) fuse_conn_info::want$set, Named.of("want()", (GetInConnInfo) FuseConnInfo::want))
+				Arguments.arguments((SetInMemorySegment) fuse_conn_info::proto_major, Named.of("protoMajor()", (GetInConnInfo) FuseConnInfo::protoMajor)),
+				Arguments.arguments((SetInMemorySegment) fuse_conn_info::proto_minor, Named.of("protoMinor()", (GetInConnInfo) FuseConnInfo::protoMinor)),
+				Arguments.arguments((SetInMemorySegment) fuse_conn_info::capable, Named.of("capable()", (GetInConnInfo) FuseConnInfo::capable)),
+				Arguments.arguments((SetInMemorySegment) fuse_conn_info::max_write, Named.of("maxWrite()", (GetInConnInfo) FuseConnInfo::maxWrite)),
+				Arguments.arguments((SetInMemorySegment) fuse_conn_info::max_read, Named.of("maxRead()", (GetInConnInfo) FuseConnInfo::maxRead)),
+				Arguments.arguments((SetInMemorySegment) fuse_conn_info::max_readahead, Named.of("maxReadahead()", (GetInConnInfo) FuseConnInfo::maxReadahead)),
+				Arguments.arguments((SetInMemorySegment) fuse_conn_info::max_background, Named.of("maxBackground()", (GetInConnInfo) FuseConnInfo::maxBackground)),
+				Arguments.arguments((SetInMemorySegment) fuse_conn_info::congestion_threshold, Named.of("congestionThreshold()", (GetInConnInfo) FuseConnInfo::congestionThreshold)),
+				Arguments.arguments((SetInMemorySegment) fuse_conn_info::time_gran, Named.of("timeGran()", (GetInConnInfo) FuseConnInfo::timeGran)),
+				Arguments.arguments((SetInMemorySegment) fuse_conn_info::want, Named.of("want()", (GetInConnInfo) FuseConnInfo::want))
 		);
 	}
 
@@ -56,7 +56,7 @@ private interface GetInConnInfo extends Function<FuseConnInfo, Integer> {}
 	public void testSetters(SetInConnInfo setter, GetInMemorySegment getter) {
 		try (var arena = Arena.ofConfined()) {
 			var segment = fuse_conn_info.allocate(arena);
-			var connInfo = new FuseConnInfoImpl(segment, arena);
+			var connInfo = new FuseConnInfoImpl(segment);
 
 			setter.accept(connInfo, 42);
 
@@ -66,13 +66,13 @@ public void testSetters(SetInConnInfo setter, GetInMemorySegment getter) {
 
 	public static Stream<Arguments> testSetters() {
 		return Stream.of(
-				Arguments.arguments(Named.of("setWant()", (SetInConnInfo) FuseConnInfo::setWant), (GetInMemorySegment) fuse_conn_info::want$get),
-				Arguments.arguments(Named.of("setMaxWrite()", (SetInConnInfo) FuseConnInfo::setMaxWrite), (GetInMemorySegment) fuse_conn_info::max_write$get),
-				Arguments.arguments(Named.of("setMaxRead()", (SetInConnInfo) FuseConnInfo::setMaxRead), (GetInMemorySegment) fuse_conn_info::max_read$get),
-				Arguments.arguments(Named.of("setMaxReadahead()", (SetInConnInfo) FuseConnInfo::setMaxReadahead), (GetInMemorySegment) fuse_conn_info::max_readahead$get),
-				Arguments.arguments(Named.of("setMaxBackground()", (SetInConnInfo) FuseConnInfo::setMaxBackground), (GetInMemorySegment) fuse_conn_info::max_background$get),
-				Arguments.arguments(Named.of("setCongestionThreshold()", (SetInConnInfo) FuseConnInfo::setCongestionThreshold), (GetInMemorySegment) fuse_conn_info::congestion_threshold$get),
-				Arguments.arguments(Named.of("setTimeGran()", (SetInConnInfo) FuseConnInfo::setTimeGran), (GetInMemorySegment) fuse_conn_info::time_gran$get)
+				Arguments.arguments(Named.of("setWant()", (SetInConnInfo) FuseConnInfo::setWant), (GetInMemorySegment) fuse_conn_info::want),
+				Arguments.arguments(Named.of("setMaxWrite()", (SetInConnInfo) FuseConnInfo::setMaxWrite), (GetInMemorySegment) fuse_conn_info::max_write),
+				Arguments.arguments(Named.of("setMaxRead()", (SetInConnInfo) FuseConnInfo::setMaxRead), (GetInMemorySegment) fuse_conn_info::max_read),
+				Arguments.arguments(Named.of("setMaxReadahead()", (SetInConnInfo) FuseConnInfo::setMaxReadahead), (GetInMemorySegment) fuse_conn_info::max_readahead),
+				Arguments.arguments(Named.of("setMaxBackground()", (SetInConnInfo) FuseConnInfo::setMaxBackground), (GetInMemorySegment) fuse_conn_info::max_background),
+				Arguments.arguments(Named.of("setCongestionThreshold()", (SetInConnInfo) FuseConnInfo::setCongestionThreshold), (GetInMemorySegment) fuse_conn_info::congestion_threshold),
+				Arguments.arguments(Named.of("setTimeGran()", (SetInConnInfo) FuseConnInfo::setTimeGran), (GetInMemorySegment) fuse_conn_info::time_gran)
 		);
 	}
 
diff --git a/jfuse-linux-aarch64/src/test/java/org/cryptomator/jfuse/linux/aarch64/FuseImplTest.java b/jfuse-linux-aarch64/src/test/java/org/cryptomator/jfuse/linux/aarch64/FuseImplTest.java
index c6295b13..f928fb76 100644
--- a/jfuse-linux-aarch64/src/test/java/org/cryptomator/jfuse/linux/aarch64/FuseImplTest.java
+++ b/jfuse-linux-aarch64/src/test/java/org/cryptomator/jfuse/linux/aarch64/FuseImplTest.java
@@ -86,7 +86,7 @@ public void testParseArgsHelp(String arg) {
 			 var fuseH = Mockito.mockStatic(fuse_h.class)) {
 			fuseFunctionsClass.when(() -> FuseFunctions.fuse_parse_cmdline(Mockito.any(), Mockito.any())).then(invocation -> {
 				MemorySegment opts = invocation.getArgument(1);
-				fuse_cmdline_opts.show_help$set(opts, 1);
+				fuse_cmdline_opts.show_help(opts, 1);
 				return 0;
 			});
 			fuseH.when(() -> fuse_h.fuse_lib_help(Mockito.any())).thenAnswer(Answers.RETURNS_DEFAULTS);
@@ -103,9 +103,9 @@ public void testParseArgs() {
 			 var arena = Arena.ofConfined()) {
 			fuseFunctionsClass.when(() -> FuseFunctions.fuse_parse_cmdline(Mockito.any(), Mockito.any())).then(invocation -> {
 				MemorySegment opts = invocation.getArgument(1);
-				fuse_cmdline_opts.singlethread$set(opts, 0);
-				fuse_cmdline_opts.debug$set(opts, 1);
-				fuse_cmdline_opts.mountpoint$set(opts, arena.allocateUtf8String("/mount/point"));
+				fuse_cmdline_opts.singlethread(opts, 0);
+				fuse_cmdline_opts.debug(opts, 1);
+				fuse_cmdline_opts.mountpoint(opts, arena.allocateFrom("/mount/point"));
 				return 0;
 			});
 
@@ -129,7 +129,7 @@ public class FlushFsyncFsyncdir {
 		@DisplayName("flush(\"/foo\", fi)")
 		public void testFlush() {
 			try (var arena = Arena.ofConfined()) {
-				var path = arena.allocateUtf8String("/foo");
+				var path = arena.allocateFrom("/foo");
 				var fi = fuse_file_info.allocate(arena);
 				Mockito.doReturn(42).when(fuseOps).flush(Mockito.eq("/foo"), Mockito.any());
 
@@ -143,7 +143,7 @@ public void testFlush() {
 		@DisplayName("fsync(\"/foo\", 1, fi)")
 		public void testFsync() {
 			try (var arena = Arena.ofConfined()) {
-				var path = arena.allocateUtf8String("/foo");
+				var path = arena.allocateFrom("/foo");
 				var fi = fuse_file_info.allocate(arena);
 				Mockito.doReturn(42).when(fuseOps).fsync(Mockito.eq("/foo"), Mockito.eq(1), Mockito.any());
 
@@ -157,7 +157,7 @@ public void testFsync() {
 		@DisplayName("fsyncdir(\"/foo\", 1, fi)")
 		public void testFsyncdir() {
 			try (var arena = Arena.ofConfined()) {
-				var path = arena.allocateUtf8String("/foo");
+				var path = arena.allocateFrom("/foo");
 				var fi = fuse_file_info.allocate(arena);
 				Mockito.doReturn(42).when(fuseOps).fsyncdir(Mockito.eq("/foo"), Mockito.eq(1), Mockito.any());
 
@@ -196,8 +196,8 @@ public class Utimens {
 		@Test
 		public void testUtimensNow() {
 			try (var arena = Arena.ofConfined()) {
-				var path = arena.allocateUtf8String("/foo");
-				var fi = arena.allocate(fuse_file_info.$LAYOUT());
+				var path = arena.allocateFrom("/foo");
+				var fi = fuse_file_info.allocate(arena);
 				var times = MemorySegment.NULL;
 				Mockito.doReturn(42).when(fuseOps).utimens(Mockito.eq("/foo"), Mockito.argThat(TimeSpec::isUtimeNow), Mockito.argThat(TimeSpec::isUtimeNow), Mockito.any());
 
@@ -217,13 +217,13 @@ public void testUtimens(long sec0, long nsec0, long sec1, long nsec1) {
 			Instant expectedATime = Instant.ofEpochSecond(sec0, nsec0);
 			Instant expectedMTime = Instant.ofEpochSecond(sec1, nsec1);
 			try (var arena = Arena.ofConfined()) {
-				var path = arena.allocateUtf8String("/foo");
-				var fi = arena.allocate(fuse_file_info.$LAYOUT());
+				var path = arena.allocateFrom("/foo");
+				var fi = fuse_file_info.allocate(arena);
 				var times = timespec.allocateArray(2, arena);
-				timespec.tv_sec$set(times, 0, sec0);
-				timespec.tv_nsec$set(times, 0, nsec0);
-				timespec.tv_sec$set(times, 1, sec1);
-				timespec.tv_nsec$set(times, 1, nsec1);
+				timespec.tv_sec(timespec.asSlice(times, 0), sec0);
+				timespec.tv_nsec(timespec.asSlice(times, 0), nsec0);
+				timespec.tv_sec(timespec.asSlice(times, 1), sec1);
+				timespec.tv_nsec(timespec.asSlice(times, 1), nsec1);
 				Mockito.doReturn(42).when(fuseOps).utimens(Mockito.eq("/foo"), Mockito.argThat(t -> expectedATime.equals(t.get())), Mockito.argThat(t -> expectedMTime.equals(t.get())), Mockito.any());
 
 				var result = fuseImpl.utimens(path, times, fi);
@@ -241,8 +241,8 @@ public class Attr {
 		@DisplayName("getxattr")
 		public void testGetxattr() {
 			try (var arena = Arena.ofConfined()) {
-				var path = arena.allocateUtf8String("/foo");
-				var name = arena.allocateUtf8String("bar");
+				var path = arena.allocateFrom("/foo");
+				var name = arena.allocateFrom("bar");
 				var value = arena.allocate(100);
 
 				Mockito.doReturn(42).when(fuseOps).getxattr(Mockito.eq("/foo"), Mockito.eq("bar"), Mockito.any());
@@ -257,8 +257,8 @@ public void testGetxattr() {
 		@DisplayName("setxattr")
 		public void testSetxattr() {
 			try (var arena = Arena.ofConfined()) {
-				var path = arena.allocateUtf8String("/foo");
-				var name = arena.allocateUtf8String("bar");
+				var path = arena.allocateFrom("/foo");
+				var name = arena.allocateFrom("bar");
 				var value = arena.allocate(100);
 
 				Mockito.doReturn(42).when(fuseOps).setxattr(Mockito.eq("/foo"), Mockito.eq("bar"), Mockito.any(), Mockito.anyInt());
@@ -273,7 +273,7 @@ public void testSetxattr() {
 		@DisplayName("listxattr")
 		public void testListxattr() {
 			try (var arena = Arena.ofConfined()) {
-				var path = arena.allocateUtf8String("/foo");
+				var path = arena.allocateFrom("/foo");
 				var list = arena.allocate(100);
 
 				Mockito.doReturn(42).when(fuseOps).listxattr(Mockito.eq("/foo"), Mockito.any());
@@ -288,8 +288,8 @@ public void testListxattr() {
 		@DisplayName("removexattr")
 		public void testRemovexattr() {
 			try (var arena = Arena.ofConfined()) {
-				var path = arena.allocateUtf8String("/foo");
-				var name = arena.allocateUtf8String("bar");
+				var path = arena.allocateFrom("/foo");
+				var name = arena.allocateFrom("bar");
 
 				Mockito.doReturn(42).when(fuseOps).removexattr(Mockito.eq("/foo"), Mockito.eq("bar"));
 
@@ -305,7 +305,7 @@ public void testRemovexattr() {
 	@DisplayName("chown")
 	public void testChown() {
 		try (var arena = Arena.ofConfined()) {
-			var path = arena.allocateUtf8String("/foo");
+			var path = arena.allocateFrom("/foo");
 			var fi = fuse_file_info.allocate(arena);
 			Mockito.doReturn(42).when(fuseOps).chown(Mockito.eq("/foo"), Mockito.eq(42), Mockito.eq(1337), Mockito.any());
 
diff --git a/jfuse-linux-aarch64/src/test/java/org/cryptomator/jfuse/linux/aarch64/StatImplTest.java b/jfuse-linux-aarch64/src/test/java/org/cryptomator/jfuse/linux/aarch64/StatImplTest.java
index 5a422c7f..1f3590a9 100644
--- a/jfuse-linux-aarch64/src/test/java/org/cryptomator/jfuse/linux/aarch64/StatImplTest.java
+++ b/jfuse-linux-aarch64/src/test/java/org/cryptomator/jfuse/linux/aarch64/StatImplTest.java
@@ -23,7 +23,7 @@ public class StatImplTest {
 	public void testGetters(SetInMemorySegment<Number> setter, GetInStat<Number> getter, Number value) {
 		try (var arena = Arena.ofConfined()) {
 			var segment = stat.allocate(arena);
-			var stat = new StatImpl(segment, arena);
+			var stat = new StatImpl(segment);
 
 			setter.accept(segment, value);
 
@@ -33,11 +33,11 @@ public void testGetters(SetInMemorySegment<Number> setter, GetInStat<Number> get
 
 	public static Stream<Arguments> testGetters() {
 		return Stream.of(
-				Arguments.arguments((SetInMemorySegment<Integer>) stat::st_mode$set, Named.of("getMode()", (GetInStat<Integer>) Stat::getMode), 42),
-				Arguments.arguments((SetInMemorySegment<Integer>) stat::st_uid$set, Named.of("getUid()", (GetInStat<Integer>) Stat::getUid), 42),
-				Arguments.arguments((SetInMemorySegment<Integer>) stat::st_gid$set, Named.of("getGid()", (GetInStat<Integer>) Stat::getGid), 42),
-				Arguments.arguments((SetInMemorySegment<Integer>) stat::st_nlink$set, Named.of("getNLink()", (GetInStat<Long>) Stat::getNLink), 42),
-				Arguments.arguments((SetInMemorySegment<Long>) stat::st_size$set, Named.of("getSize()", (GetInStat<Long>) Stat::getSize), 42L)
+				Arguments.arguments((SetInMemorySegment<Integer>) stat::st_mode, Named.of("getMode()", (GetInStat<Integer>) Stat::getMode), 42),
+				Arguments.arguments((SetInMemorySegment<Integer>) stat::st_uid, Named.of("getUid()", (GetInStat<Integer>) Stat::getUid), 42),
+				Arguments.arguments((SetInMemorySegment<Integer>) stat::st_gid, Named.of("getGid()", (GetInStat<Integer>) Stat::getGid), 42),
+				Arguments.arguments((SetInMemorySegment<Integer>) stat::st_nlink, Named.of("getNLink()", (GetInStat<Long>) Stat::getNLink), 42),
+				Arguments.arguments((SetInMemorySegment<Long>) stat::st_size, Named.of("getSize()", (GetInStat<Long>) Stat::getSize), 42L)
 		);
 	}
 
@@ -51,7 +51,7 @@ private interface GetInStat<T> extends Function<Stat, T> {}
 	public void testSetters(SetInStat<Number> setter, GetInMemorySegment<Number> getter, Number value) {
 		try (var arena = Arena.ofConfined()) {
 			var segment = stat.allocate(arena);
-			var stat = new StatImpl(segment, arena);
+			var stat = new StatImpl(segment);
 
 			setter.accept(stat, value);
 
@@ -61,11 +61,11 @@ public void testSetters(SetInStat<Number> setter, GetInMemorySegment<Number> get
 
 	public static Stream<Arguments> testSetters() {
 		return Stream.of(
-				Arguments.arguments(Named.of("setMode()", (SetInStat<Integer>) Stat::setMode), (GetInMemorySegment<Integer>) stat::st_mode$get, 42),
-				Arguments.arguments(Named.of("setUid()", (SetInStat<Integer>) Stat::setUid), (GetInMemorySegment<Integer>) stat::st_uid$get, 42),
-				Arguments.arguments(Named.of("setGid()", (SetInStat<Integer>) Stat::setGid), (GetInMemorySegment<Integer>) stat::st_gid$get, 42),
-				Arguments.arguments(Named.of("setNLink()", (SetInStat<Short>) Stat::setNLink), (GetInMemorySegment<Integer>) stat::st_nlink$get, (short) 42),
-				Arguments.arguments(Named.of("setSize()", (SetInStat<Long>) Stat::setSize), (GetInMemorySegment<Long>) stat::st_size$get, 42L)
+				Arguments.arguments(Named.of("setMode()", (SetInStat<Integer>) Stat::setMode), (GetInMemorySegment<Integer>) stat::st_mode, 42),
+				Arguments.arguments(Named.of("setUid()", (SetInStat<Integer>) Stat::setUid), (GetInMemorySegment<Integer>) stat::st_uid, 42),
+				Arguments.arguments(Named.of("setGid()", (SetInStat<Integer>) Stat::setGid), (GetInMemorySegment<Integer>) stat::st_gid, 42),
+				Arguments.arguments(Named.of("setNLink()", (SetInStat<Short>) Stat::setNLink), (GetInMemorySegment<Integer>) stat::st_nlink, (short) 42),
+				Arguments.arguments(Named.of("setSize()", (SetInStat<Long>) Stat::setSize), (GetInMemorySegment<Long>) stat::st_size, 42L)
 		);
 	}
 
diff --git a/jfuse-linux-aarch64/src/test/java/org/cryptomator/jfuse/linux/aarch64/TimeSpecImplTest.java b/jfuse-linux-aarch64/src/test/java/org/cryptomator/jfuse/linux/aarch64/TimeSpecImplTest.java
index fc2893f9..7f944fe9 100644
--- a/jfuse-linux-aarch64/src/test/java/org/cryptomator/jfuse/linux/aarch64/TimeSpecImplTest.java
+++ b/jfuse-linux-aarch64/src/test/java/org/cryptomator/jfuse/linux/aarch64/TimeSpecImplTest.java
@@ -16,8 +16,8 @@ public class TimeSpecImplTest {
 	public void testGet() {
 		try (var arena = Arena.ofConfined()) {
 			var timeSpec = new TimeSpecImpl(timespec.allocate(arena));
-			timespec.tv_sec$set(timeSpec.segment(), 123L);
-			timespec.tv_nsec$set(timeSpec.segment(), 456L);
+			timespec.tv_sec(timeSpec.segment(), 123L);
+			timespec.tv_nsec(timeSpec.segment(), 456L);
 
 			var result = timeSpec.get();
 
@@ -31,13 +31,13 @@ public void testGet() {
 	public void testSet() {
 		try (var arena = Arena.ofConfined()) {
 			var timeSpec = new TimeSpecImpl(timespec.allocate(arena));
-			timespec.tv_sec$set(timeSpec.segment(), 0L);
-			timespec.tv_nsec$set(timeSpec.segment(), 0L);
+			timespec.tv_sec(timeSpec.segment(), 0L);
+			timespec.tv_nsec(timeSpec.segment(), 0L);
 
 			timeSpec.set(Instant.ofEpochSecond(123L, 456L));
 
-			Assertions.assertEquals(123L, timespec.tv_sec$get(timeSpec.segment()));
-			Assertions.assertEquals(456L, timespec.tv_nsec$get(timeSpec.segment()));
+			Assertions.assertEquals(123L, timespec.tv_sec(timeSpec.segment()));
+			Assertions.assertEquals(456L, timespec.tv_nsec(timeSpec.segment()));
 		}
 	}
 
@@ -46,8 +46,8 @@ public void testSet() {
 	public void testIsUtimeOmit() {
 		try (var arena = Arena.ofConfined()) {
 			var timeSpec = new TimeSpecImpl(timespec.allocate(arena));
-			timespec.tv_sec$set(timeSpec.segment(), 123L);
-			timespec.tv_nsec$set(timeSpec.segment(), stat_h.UTIME_OMIT());
+			timespec.tv_sec(timeSpec.segment(), 123L);
+			timespec.tv_nsec(timeSpec.segment(), stat_h.UTIME_OMIT());
 
 			Assertions.assertTrue(timeSpec.isUtimeOmit());
 			Assertions.assertFalse(timeSpec.isUtimeNow());
@@ -59,8 +59,8 @@ public void testIsUtimeOmit() {
 	public void testIsUtimeNow() {
 		try (var arena = Arena.ofConfined()) {
 			var timeSpec = new TimeSpecImpl(timespec.allocate(arena));
-			timespec.tv_sec$set(timeSpec.segment(), 123L);
-			timespec.tv_nsec$set(timeSpec.segment(), stat_h.UTIME_NOW());
+			timespec.tv_sec(timeSpec.segment(), 123L);
+			timespec.tv_nsec(timeSpec.segment(), stat_h.UTIME_NOW());
 
 			Assertions.assertFalse(timeSpec.isUtimeOmit());
 			Assertions.assertTrue(timeSpec.isUtimeNow());
diff --git a/jfuse-linux-amd64/pom.xml b/jfuse-linux-amd64/pom.xml
index 04f04b8c..dc14f296 100644
--- a/jfuse-linux-amd64/pom.xml
+++ b/jfuse-linux-amd64/pom.xml
@@ -31,7 +31,7 @@
 				<groupId>org.apache.maven.plugins</groupId>
 				<artifactId>maven-surefire-plugin</artifactId>
 				<configuration>
-					<argLine>@{surefire.jacoco.args} -javaagent:${net.bytebuddy:byte-buddy-agent:jar} --enable-preview --enable-native-access=org.cryptomator.jfuse.linux.amd64</argLine>
+					<argLine>@{surefire.jacoco.args} -javaagent:${net.bytebuddy:byte-buddy-agent:jar} --enable-native-access=org.cryptomator.jfuse.linux.amd64</argLine>
 				</configuration>
 			</plugin>
 		</plugins>
@@ -81,7 +81,7 @@
 					<plugin>
 						<groupId>io.github.coffeelibs</groupId>
 						<artifactId>jextract-maven-plugin</artifactId>
-						<version>0.3.0</version>
+						<version>0.4.0</version>
 						<configuration>
 							<executable>/Users/sebastian/git/github.com/openjdk/jextract/build/jextract/bin/jextract</executable>
 							<headerSearchPaths>${linux.headerSearchPath}</headerSearchPaths>
diff --git a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/DirFillerImpl.java b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/DirFillerImpl.java
index 9f55bcee..004053c3 100644
--- a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/DirFillerImpl.java
+++ b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/DirFillerImpl.java
@@ -9,17 +9,13 @@
 import java.lang.foreign.MemorySegment;
 import java.util.function.Consumer;
 
-record DirFillerImpl(MemorySegment buf, fuse_fill_dir_t callback, Arena arena) implements DirFiller {
-
-	DirFillerImpl(MemorySegment buf, MemorySegment callback, Arena arena) {
-		this(buf, fuse_fill_dir_t.ofAddress(callback, arena), arena);
-	}
+record DirFillerImpl(MemorySegment buf, MemorySegment callback, Arena arena) implements DirFiller {
 
 	@Override
 	public int fill(String name, Consumer<Stat> statFiller, long offset, int flags) {
 		var statSegment = stat.allocate(arena);
 		statFiller.accept(new StatImpl(statSegment));
-		return callback.apply(buf, arena.allocateUtf8String(name), statSegment, offset, flags);
+		return fuse_fill_dir_t.invoke(callback, buf, arena.allocateFrom(name), statSegment, offset, flags);
 	}
 
 }
\ No newline at end of file
diff --git a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/FileInfoImpl.java b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/FileInfoImpl.java
index e687f6fa..dc70ab7e 100644
--- a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/FileInfoImpl.java
+++ b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/FileInfoImpl.java
@@ -5,7 +5,6 @@
 import org.cryptomator.jfuse.linux.amd64.extr.fuse3.fuse_file_info;
 import org.jetbrains.annotations.Nullable;
 
-import java.lang.foreign.Arena;
 import java.lang.foreign.MemorySegment;
 import java.nio.file.StandardOpenOption;
 import java.util.EnumSet;
@@ -24,34 +23,29 @@ record FileInfoImpl(MemorySegment segment) implements FileInfo {
 	private static final int O_DSYNC = fcntl_h.O_DSYNC();
 
 	/**
-	 * Factory method to map native memory to an {@link FileInfo} object
+	 * Null-safe factory method to map native memory to an {@link FileInfo} object
 	 *
 	 * @param address the {@link MemorySegment} representing the starting address
-	 * @param scope   the {@link Arena} in which this object will be alive
 	 * @return an {@link FileInfo} object or {@code null} if {@code address} is a NULL pointer
 	 */
 	@Nullable
-	public static FileInfoImpl of(MemorySegment address, Arena scope) {
-		return MemorySegment.NULL.equals(address) ? null : new FileInfoImpl(address, scope);
-	}
-
-	public FileInfoImpl(MemorySegment address, Arena scope) {
-		this(fuse_file_info.ofAddress(address, scope));
+	public static FileInfoImpl ofNullable(MemorySegment address) {
+		return MemorySegment.NULL.equals(address) ? null : new FileInfoImpl(address);
 	}
 
 	@Override
 	public long getFh() {
-		return fuse_file_info.fh$get(segment);
+		return fuse_file_info.fh(segment);
 	}
 
 	@Override
 	public void setFh(long fh) {
-		fuse_file_info.fh$set(segment, fh);
+		fuse_file_info.fh(segment, fh);
 	}
 
 	@Override
 	public int getFlags() {
-		return fuse_file_info.flags$get(segment);
+		return fuse_file_info.flags(segment);
 	}
 
 	@Override
@@ -91,7 +85,7 @@ public Set<StandardOpenOption> getOpenFlags() {
 
 	@Override
 	public long getLockOwner() {
-		return fuse_file_info.lock_owner$get(segment);
+		return fuse_file_info.lock_owner(segment);
 	}
 
 }
diff --git a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/FuseArgs.java b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/FuseArgs.java
index 732c7e4e..b0159c47 100644
--- a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/FuseArgs.java
+++ b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/FuseArgs.java
@@ -11,36 +11,36 @@ record FuseArgs(MemorySegment args, MemorySegment cmdLineOpts) {
 	@Override
 	public String toString() {
 		var sb = new StringBuilder();
-		var argc = fuse_args.argc$get(args);
-		var argv = fuse_args.argv$get(args);
+		var argc = fuse_args.argc(args);
+		var argv = fuse_args.argv(args);
 		for (int i = 0; i < argc; i++) {
 			var cString = argv.getAtIndex(ValueLayout.ADDRESS, i).reinterpret(Long.MAX_VALUE);
-			sb.append("arg[").append(i).append("] = ").append(cString.getUtf8String(0)).append(", ");
+			sb.append("arg[").append(i).append("] = ").append(cString.getString(0)).append(", ");
 		}
-		sb.append("mountPoint = ").append(mountPoint().getUtf8String(0));
-		sb.append("debug = ").append(fuse_cmdline_opts.debug$get(cmdLineOpts));
+		sb.append("mountPoint = ").append(mountPoint().getString(0));
+		sb.append("debug = ").append(fuse_cmdline_opts.debug(cmdLineOpts));
 		sb.append("singlethreaded = ").append(!multithreaded());
 		return sb.toString();
 	}
 
 	public MemorySegment mountPoint() {
-		return fuse_cmdline_opts.mountpoint$get(cmdLineOpts);
+		return fuse_cmdline_opts.mountpoint(cmdLineOpts);
 	}
 
 	public boolean multithreaded() {
-		return fuse_cmdline_opts.singlethread$get(cmdLineOpts) == 0;
+		return fuse_cmdline_opts.singlethread(cmdLineOpts) == 0;
 	}
 
 	public int cloneFd() {
-		return fuse_cmdline_opts.clone_fd$get(cmdLineOpts);
+		return fuse_cmdline_opts.clone_fd(cmdLineOpts);
 	}
 
 	public int maxIdleThreads() {
-		return fuse_cmdline_opts.max_idle_threads$get(cmdLineOpts);
+		return fuse_cmdline_opts.max_idle_threads(cmdLineOpts);
 	}
 
 	public int maxThreads() {
-		return fuse_cmdline_opts.max_threads$get(cmdLineOpts);
+		return fuse_cmdline_opts.max_threads(cmdLineOpts);
 	}
 
 }
diff --git a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/FuseConfigImpl.java b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/FuseConfigImpl.java
index ef4ecb26..0251227f 100644
--- a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/FuseConfigImpl.java
+++ b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/FuseConfigImpl.java
@@ -8,118 +8,114 @@
 
 record FuseConfigImpl(MemorySegment segment) implements FuseConfig {
 
-	public FuseConfigImpl(MemorySegment address, Arena scope) {
-		this(fuse_config.ofAddress(address, scope));
-	}
-
 	@Override
 	public int setGid() {
-		return fuse_config.set_gid$get(segment);
+		return fuse_config.set_gid(segment);
 	}
 
 	@Override
 	public int gid() {
-		return fuse_config.gid$get(segment);
+		return fuse_config.gid(segment);
 	}
 
 	@Override
 	public int setUid() {
-		return fuse_config.set_uid$get(segment);
+		return fuse_config.set_uid(segment);
 	}
 
 	@Override
 	public int uid() {
-		return fuse_config.uid$get(segment);
+		return fuse_config.uid(segment);
 	}
 
 	@Override
 	public int setMode() {
-		return fuse_config.set_mode$get(segment);
+		return fuse_config.set_mode(segment);
 	}
 
 	@Override
 	public int umask() {
-		return fuse_config.umask$get(segment);
+		return fuse_config.umask(segment);
 	}
 
 	@Override
 	public double entryTimeout() {
-		return fuse_config.entry_timeout$get(segment);
+		return fuse_config.entry_timeout(segment);
 	}
 
 	@Override
 	public double negativeTimeout() {
-		return fuse_config.negative_timeout$get(segment);
+		return fuse_config.negative_timeout(segment);
 	}
 
 	@Override
 	public double attrTimeout() {
-		return fuse_config.attr_timeout$get(segment);
+		return fuse_config.attr_timeout(segment);
 	}
 
 	@Override
 	public int intr() {
-		return fuse_config.intr$get(segment);
+		return fuse_config.intr(segment);
 	}
 
 	@Override
 	public int intrSignal() {
-		return fuse_config.intr_signal$get(segment);
+		return fuse_config.intr_signal(segment);
 	}
 
 	@Override
 	public int remember() {
-		return fuse_config.remember$get(segment);
+		return fuse_config.remember(segment);
 	}
 
 	@Override
 	public int hardRemove() {
-		return fuse_config.hard_remove$get(segment);
+		return fuse_config.hard_remove(segment);
 	}
 
 	@Override
 	public int useIno() {
-		return fuse_config.use_ino$get(segment);
+		return fuse_config.use_ino(segment);
 	}
 
 	@Override
 	public int readdirIno() {
-		return fuse_config.readdir_ino$get(segment);
+		return fuse_config.readdir_ino(segment);
 	}
 
 	@Override
 	public int directIo() {
-		return fuse_config.direct_io$get(segment);
+		return fuse_config.direct_io(segment);
 	}
 
 	@Override
 	public int kernelCache() {
-		return fuse_config.kernel_cache$get(segment);
+		return fuse_config.kernel_cache(segment);
 	}
 
 	@Override
 	public int autoCache() {
-		return fuse_config.auto_cache$get(segment);
+		return fuse_config.auto_cache(segment);
 	}
 
 	@Override
 	public int acAttrTimeoutSet() {
-		return fuse_config.ac_attr_timeout_set$get(segment);
+		return fuse_config.ac_attr_timeout_set(segment);
 	}
 
 	@Override
 	public double acAttrTimeout() {
-		return fuse_config.ac_attr_timeout$get(segment);
+		return fuse_config.ac_attr_timeout(segment);
 	}
 
 	@Override
 	public int nullpathOk() {
-		return fuse_config.nullpath_ok$get(segment);
+		return fuse_config.nullpath_ok(segment);
 	}
 
 	@Override
 	public int noRofdFlush() {
-		return fuse_config.no_rofd_flush$get(segment);
+		return fuse_config.no_rofd_flush(segment);
 	}
 
 }
diff --git a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/FuseConnInfoImpl.java b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/FuseConnInfoImpl.java
index f886c9a7..487e0c44 100644
--- a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/FuseConnInfoImpl.java
+++ b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/FuseConnInfoImpl.java
@@ -8,93 +8,89 @@
 
 record FuseConnInfoImpl(MemorySegment segment) implements FuseConnInfo {
 
-	public FuseConnInfoImpl(MemorySegment address, Arena scope) {
-		this(fuse_conn_info.ofAddress(address, scope));
-	}
-
 	@Override
 	public int protoMajor() {
-		return fuse_conn_info.proto_major$get(segment);
+		return fuse_conn_info.proto_major(segment);
 	}
 
 	@Override
 	public int protoMinor() {
-		return fuse_conn_info.proto_minor$get(segment);
+		return fuse_conn_info.proto_minor(segment);
 	}
 
 	@Override
 	public int capable() {
-		return fuse_conn_info.capable$get(segment);
+		return fuse_conn_info.capable(segment);
 	}
 
 	@Override
 	public int want() {
-		return fuse_conn_info.want$get(segment);
+		return fuse_conn_info.want(segment);
 	}
 
 	@Override
 	public void setWant(int wanted) {
-		fuse_conn_info.want$set(segment, wanted);
+		fuse_conn_info.want(segment, wanted);
 	}
 
 	@Override
 	public int maxWrite() {
-		return fuse_conn_info.max_write$get(segment);
+		return fuse_conn_info.max_write(segment);
 	}
 
 	@Override
 	public void setMaxWrite(int maxWrite) {
-		fuse_conn_info.max_write$set(segment, maxWrite);
+		fuse_conn_info.max_write(segment, maxWrite);
 	}
 
 	@Override
 	public int maxRead() {
-		return fuse_conn_info.max_read$get(segment);
+		return fuse_conn_info.max_read(segment);
 	}
 
 	@Override
 	public void setMaxRead(int maxRead) {
-		fuse_conn_info.max_read$set(segment, maxRead);
+		fuse_conn_info.max_read(segment, maxRead);
 	}
 
 	@Override
 	public int maxReadahead() {
-		return fuse_conn_info.max_readahead$get(segment);
+		return fuse_conn_info.max_readahead(segment);
 	}
 
 	@Override
 	public void setMaxReadahead(int maxReadahead) {
-		fuse_conn_info.max_readahead$set(segment, maxReadahead);
+		fuse_conn_info.max_readahead(segment, maxReadahead);
 	}
 
 	@Override
 	public int maxBackground() {
-		return fuse_conn_info.max_background$get(segment);
+		return fuse_conn_info.max_background(segment);
 	}
 
 	@Override
 	public void setMaxBackground(int maxBackground) {
-		fuse_conn_info.max_background$set(segment, maxBackground);
+		fuse_conn_info.max_background(segment, maxBackground);
 	}
 
 	@Override
 	public int congestionThreshold() {
-		return fuse_conn_info.congestion_threshold$get(segment);
+		return fuse_conn_info.congestion_threshold(segment);
 	}
 
 	@Override
 	public void setCongestionThreshold(int congestionThreshold) {
-		fuse_conn_info.congestion_threshold$set(segment, congestionThreshold);
+		fuse_conn_info.congestion_threshold(segment, congestionThreshold);
 	}
 
 	@Override
 	public int timeGran() {
-		return fuse_conn_info.time_gran$get(segment);
+		return fuse_conn_info.time_gran(segment);
 	}
 
 	@Override
 	public void setTimeGran(int timeGran) {
-		fuse_conn_info.time_gran$set(segment, timeGran);
+		fuse_conn_info.time_gran(segment, timeGran);
 	}
 
 }
diff --git a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/FuseImpl.java b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/FuseImpl.java
index dc4ef78c..650cdd27 100644
--- a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/FuseImpl.java
+++ b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/FuseImpl.java
@@ -42,22 +42,22 @@ protected FuseMount mount(List<String> args) throws FuseMountFailedException {
 	FuseArgs parseArgs(List<String> cmdLineArgs) throws IllegalArgumentException {
 		var args = fuse_args.allocate(fuseArena);
 		var argc = cmdLineArgs.size();
-		var argv = fuseArena.allocateArray(ValueLayout.ADDRESS, argc + 1L);
+		var argv = fuseArena.allocate(ValueLayout.ADDRESS, argc + 1L);
 		for (int i = 0; i < argc; i++) {
-			var cString = fuseArena.allocateUtf8String(cmdLineArgs.get(i));
+			var cString = fuseArena.allocateFrom(cmdLineArgs.get(i));
 			argv.setAtIndex(ValueLayout.ADDRESS, i, cString);
 		}
 		argv.setAtIndex(ValueLayout.ADDRESS, argc, MemorySegment.NULL);
-		fuse_args.argc$set(args, argc);
-		fuse_args.argv$set(args, argv);
-		fuse_args.allocated$set(args, 0);
+		fuse_args.argc(args, argc);
+		fuse_args.argv(args, argv);
+		fuse_args.allocated(args, 0);
 
 		var opts = fuse_cmdline_opts.allocate(fuseArena);
 		int parseResult = FuseFunctions.fuse_parse_cmdline(args, opts);
 		if (parseResult != 0) {
 			throw new IllegalArgumentException("fuse_parse_cmdline failed to parse " + String.join(" ", cmdLineArgs));
 		}
-		if (fuse_cmdline_opts.show_help$get(opts) == 1) {
+		if (fuse_cmdline_opts.show_help(opts) == 1) {
 			fuse_h.fuse_lib_help(args);
 			throw new IllegalArgumentException("Flags contained -h or --help. Processing cancelled after printing help");
 		}
@@ -67,71 +67,63 @@ FuseArgs parseArgs(List<String> cmdLineArgs) throws IllegalArgumentException {
 	@Override
 	protected void bind(FuseOperations.Operation operation) {
 		switch (operation) {
-			case INIT -> fuse_operations.init$set(fuseOperationsStruct, fuse_operations.init.allocate(this::init, fuseArena));
-			case ACCESS -> fuse_operations.access$set(fuseOperationsStruct, fuse_operations.access.allocate(this::access, fuseArena));
-			case CHMOD -> fuse_operations.chmod$set(fuseOperationsStruct, fuse_operations.chmod.allocate(this::chmod, fuseArena));
-			case CHOWN -> fuse_operations.chown$set(fuseOperationsStruct, fuse_operations.chown.allocate(this::chown, fuseArena));
-			case CREATE -> fuse_operations.create$set(fuseOperationsStruct, fuse_operations.create.allocate(this::create, fuseArena));
-			case DESTROY -> fuse_operations.destroy$set(fuseOperationsStruct, fuse_operations.destroy.allocate(this::destroy, fuseArena));
-			case FLUSH -> fuse_operations.flush$set(fuseOperationsStruct, fuse_operations.flush.allocate(this::flush, fuseArena));
-			case FSYNC -> fuse_operations.fsync$set(fuseOperationsStruct, fuse_operations.fsync.allocate(this::fsync, fuseArena));
-			case FSYNCDIR -> fuse_operations.fsyncdir$set(fuseOperationsStruct, fuse_operations.fsyncdir.allocate(this::fsyncdir, fuseArena));
-			case GET_ATTR -> fuse_operations.getattr$set(fuseOperationsStruct, fuse_operations.getattr.allocate(this::getattr, fuseArena));
-			case GET_XATTR -> fuse_operations.getxattr$set(fuseOperationsStruct, fuse_operations.getxattr.allocate(this::getxattr, fuseArena));
-			case LIST_XATTR -> fuse_operations.listxattr$set(fuseOperationsStruct, fuse_operations.listxattr.allocate(this::listxattr, fuseArena));
-			case MKDIR -> fuse_operations.mkdir$set(fuseOperationsStruct, fuse_operations.mkdir.allocate(this::mkdir, fuseArena));
-			case OPEN -> fuse_operations.open$set(fuseOperationsStruct, fuse_operations.open.allocate(this::open, fuseArena));
-			case OPEN_DIR -> fuse_operations.opendir$set(fuseOperationsStruct, fuse_operations.opendir.allocate(this::opendir, fuseArena));
-			case READ -> fuse_operations.read$set(fuseOperationsStruct, fuse_operations.read.allocate(this::read, fuseArena));
-			case READ_DIR -> fuse_operations.readdir$set(fuseOperationsStruct, fuse_operations.readdir.allocate(this::readdir, fuseArena));
-			case READLINK -> fuse_operations.readlink$set(fuseOperationsStruct, fuse_operations.readlink.allocate(this::readlink, fuseArena));
-			case RELEASE -> fuse_operations.release$set(fuseOperationsStruct, fuse_operations.release.allocate(this::release, fuseArena));
-			case RELEASE_DIR -> fuse_operations.releasedir$set(fuseOperationsStruct, fuse_operations.releasedir.allocate(this::releasedir, fuseArena));
-			case REMOVE_XATTR -> fuse_operations.removexattr$set(fuseOperationsStruct, fuse_operations.removexattr.allocate(this::removexattr, fuseArena));
-			case RENAME -> fuse_operations.rename$set(fuseOperationsStruct, fuse_operations.rename.allocate(this::rename, fuseArena));
-			case RMDIR -> fuse_operations.rmdir$set(fuseOperationsStruct, fuse_operations.rmdir.allocate(this::rmdir, fuseArena));
-			case SET_XATTR -> fuse_operations.setxattr$set(fuseOperationsStruct, fuse_operations.setxattr.allocate(this::setxattr, fuseArena));
-			case STATFS -> fuse_operations.statfs$set(fuseOperationsStruct, fuse_operations.statfs.allocate(this::statfs, fuseArena));
-			case SYMLINK -> fuse_operations.symlink$set(fuseOperationsStruct, fuse_operations.symlink.allocate(this::symlink, fuseArena));
-			case TRUNCATE -> fuse_operations.truncate$set(fuseOperationsStruct, fuse_operations.truncate.allocate(this::truncate, fuseArena));
-			case UNLINK -> fuse_operations.unlink$set(fuseOperationsStruct, fuse_operations.unlink.allocate(this::unlink, fuseArena));
-			case UTIMENS -> fuse_operations.utimens$set(fuseOperationsStruct, fuse_operations.utimens.allocate(this::utimens, fuseArena));
-			case WRITE -> fuse_operations.write$set(fuseOperationsStruct, fuse_operations.write.allocate(this::write, fuseArena));
+			case INIT -> fuse_operations.init(fuseOperationsStruct, fuse_operations.init.allocate(this::init, fuseArena));
+			case ACCESS -> fuse_operations.access(fuseOperationsStruct, fuse_operations.access.allocate(this::access, fuseArena));
+			case CHMOD -> fuse_operations.chmod(fuseOperationsStruct, fuse_operations.chmod.allocate(this::chmod, fuseArena));
+			case CHOWN -> fuse_operations.chown(fuseOperationsStruct, fuse_operations.chown.allocate(this::chown, fuseArena));
+			case CREATE -> fuse_operations.create(fuseOperationsStruct, fuse_operations.create.allocate(this::create, fuseArena));
+			case DESTROY -> fuse_operations.destroy(fuseOperationsStruct, fuse_operations.destroy.allocate(this::destroy, fuseArena));
+			case FLUSH -> fuse_operations.flush(fuseOperationsStruct, fuse_operations.flush.allocate(this::flush, fuseArena));
+			case FSYNC -> fuse_operations.fsync(fuseOperationsStruct, fuse_operations.fsync.allocate(this::fsync, fuseArena));
+			case FSYNCDIR -> fuse_operations.fsyncdir(fuseOperationsStruct, fuse_operations.fsyncdir.allocate(this::fsyncdir, fuseArena));
+			case GET_ATTR -> fuse_operations.getattr(fuseOperationsStruct, fuse_operations.getattr.allocate(this::getattr, fuseArena));
+			case GET_XATTR -> fuse_operations.getxattr(fuseOperationsStruct, fuse_operations.getxattr.allocate(this::getxattr, fuseArena));
+			case LIST_XATTR -> fuse_operations.listxattr(fuseOperationsStruct, fuse_operations.listxattr.allocate(this::listxattr, fuseArena));
+			case MKDIR -> fuse_operations.mkdir(fuseOperationsStruct, fuse_operations.mkdir.allocate(this::mkdir, fuseArena));
+			case OPEN -> fuse_operations.open(fuseOperationsStruct, fuse_operations.open.allocate(this::open, fuseArena));
+			case OPEN_DIR -> fuse_operations.opendir(fuseOperationsStruct, fuse_operations.opendir.allocate(this::opendir, fuseArena));
+			case READ -> fuse_operations.read(fuseOperationsStruct, fuse_operations.read.allocate(this::read, fuseArena));
+			case READ_DIR -> fuse_operations.readdir(fuseOperationsStruct, fuse_operations.readdir.allocate(this::readdir, fuseArena));
+			case READLINK -> fuse_operations.readlink(fuseOperationsStruct, fuse_operations.readlink.allocate(this::readlink, fuseArena));
+			case RELEASE -> fuse_operations.release(fuseOperationsStruct, fuse_operations.release.allocate(this::release, fuseArena));
+			case RELEASE_DIR -> fuse_operations.releasedir(fuseOperationsStruct, fuse_operations.releasedir.allocate(this::releasedir, fuseArena));
+			case REMOVE_XATTR -> fuse_operations.removexattr(fuseOperationsStruct, fuse_operations.removexattr.allocate(this::removexattr, fuseArena));
+			case RENAME -> fuse_operations.rename(fuseOperationsStruct, fuse_operations.rename.allocate(this::rename, fuseArena));
+			case RMDIR -> fuse_operations.rmdir(fuseOperationsStruct, fuse_operations.rmdir.allocate(this::rmdir, fuseArena));
+			case SET_XATTR -> fuse_operations.setxattr(fuseOperationsStruct, fuse_operations.setxattr.allocate(this::setxattr, fuseArena));
+			case STATFS -> fuse_operations.statfs(fuseOperationsStruct, fuse_operations.statfs.allocate(this::statfs, fuseArena));
+			case SYMLINK -> fuse_operations.symlink(fuseOperationsStruct, fuse_operations.symlink.allocate(this::symlink, fuseArena));
+			case TRUNCATE -> fuse_operations.truncate(fuseOperationsStruct, fuse_operations.truncate.allocate(this::truncate, fuseArena));
+			case UNLINK -> fuse_operations.unlink(fuseOperationsStruct, fuse_operations.unlink.allocate(this::unlink, fuseArena));
+			case UTIMENS -> fuse_operations.utimens(fuseOperationsStruct, fuse_operations.utimens.allocate(this::utimens, fuseArena));
+			case WRITE -> fuse_operations.write(fuseOperationsStruct, fuse_operations.write.allocate(this::write, fuseArena));
 		}
 	}
 
 	@VisibleForTesting
 	MemorySegment init(MemorySegment conn, MemorySegment cfg) {
-		try (var arena = Arena.ofConfined()) {
-			var connInfo = new FuseConnInfoImpl(conn, arena);
-			connInfo.setWant(connInfo.want() | FuseConnInfo.FUSE_CAP_READDIRPLUS);
-			var config = new FuseConfigImpl(cfg, arena);
-			fuseOperations.init(connInfo, config);
-		}
+		var connInfo = new FuseConnInfoImpl(conn);
+		connInfo.setWant(connInfo.want() | FuseConnInfo.FUSE_CAP_READDIRPLUS);
+		var config = new FuseConfigImpl(cfg);
+		fuseOperations.init(connInfo, config);
 		return MemorySegment.NULL;
 	}
 
 	private int access(MemorySegment path, int mask) {
-		return fuseOperations.access(path.getUtf8String(0), mask);
+		return fuseOperations.access(path.getString(0), mask);
 	}
 
 	private int chmod(MemorySegment path, int mode, MemorySegment fi) {
-		try (var arena = Arena.ofConfined()) {
-			return fuseOperations.chmod(path.getUtf8String(0), mode, FileInfoImpl.of(fi, arena));
-		}
+		return fuseOperations.chmod(path.getString(0), mode, FileInfoImpl.ofNullable(fi));
 	}
 
 	@VisibleForTesting
 	int chown(MemorySegment path, int uid, int gid, MemorySegment fi) {
-		try (var arena = Arena.ofConfined()) {
-			return fuseOperations.chown(path.getUtf8String(0), uid, gid, FileInfoImpl.of(fi, arena));
-		}
+		return fuseOperations.chown(path.getString(0), uid, gid, FileInfoImpl.ofNullable(fi));
 	}
 
 	private int create(MemorySegment path, int mode, MemorySegment fi) {
-		try (var arena = Arena.ofConfined()) {
-			return fuseOperations.create(path.getUtf8String(0), mode, new FileInfoImpl(fi, arena));
-		}
+		return fuseOperations.create(path.getString(0), mode, new FileInfoImpl(fi));
 	}
 
 	private void destroy(MemorySegment addr) {
@@ -140,126 +132,104 @@ private void destroy(MemorySegment addr) {
 
 	@VisibleForTesting
 	int flush(MemorySegment path, MemorySegment fi) {
-		try (var arena = Arena.ofConfined()) {
-			return fuseOperations.flush(path.getUtf8String(0), new FileInfoImpl(fi, arena));
-		}
+		return fuseOperations.flush(path.getString(0), new FileInfoImpl(fi));
 	}
 
 	@VisibleForTesting
 	int fsync(MemorySegment path, int datasync, MemorySegment fi) {
-		try (var arena = Arena.ofConfined()) {
-			return fuseOperations.fsync(path.getUtf8String(0), datasync, new FileInfoImpl(fi, arena));
-		}
+		return fuseOperations.fsync(path.getString(0), datasync, new FileInfoImpl(fi));
 	}
 
 	@VisibleForTesting
 	int fsyncdir(MemorySegment path, int datasync, MemorySegment fi) {
-		try (var arena = Arena.ofConfined()) {
-			return fuseOperations.fsyncdir(MemoryUtils.toUtf8StringOrNull(path), datasync, new FileInfoImpl(fi, arena));
-		}
+		return fuseOperations.fsyncdir(MemoryUtils.toUtf8StringOrNull(path), datasync, new FileInfoImpl(fi));
 	}
 
 	private int getattr(MemorySegment path, MemorySegment stat, MemorySegment fi) {
-		try (var arena = Arena.ofConfined()) {
-			return fuseOperations.getattr(path.getUtf8String(0), new StatImpl(stat, arena), FileInfoImpl.of(fi, arena));
-		}
+		return fuseOperations.getattr(path.getString(0), new StatImpl(stat), FileInfoImpl.ofNullable(fi));
 	}
 
 	@VisibleForTesting
 	int getxattr(MemorySegment path, MemorySegment name, MemorySegment value, long size) {
 		var val = value.reinterpret(size).asByteBuffer();
-		return fuseOperations.getxattr(path.getUtf8String(0), name.getUtf8String(0), val);
+		return fuseOperations.getxattr(path.getString(0), name.getString(0), val);
 	}
 
 	@VisibleForTesting
 	int setxattr(MemorySegment path, MemorySegment name, MemorySegment value, long size, int flags) {
 		var val = value.reinterpret(size).asByteBuffer();
-		return fuseOperations.setxattr(path.getUtf8String(0), name.getUtf8String(0), val, flags);
+		return fuseOperations.setxattr(path.getString(0), name.getString(0), val, flags);
 	}
 
 	@VisibleForTesting
 	int listxattr(MemorySegment path, MemorySegment value, long size) {
 		var val = value.reinterpret(size).asByteBuffer();
-		return fuseOperations.listxattr(path.getUtf8String(0), val);
+		return fuseOperations.listxattr(path.getString(0), val);
 	}
 
 	@VisibleForTesting
 	int removexattr(MemorySegment path, MemorySegment name) {
-		return fuseOperations.removexattr(path.getUtf8String(0), name.getUtf8String(0));
+		return fuseOperations.removexattr(path.getString(0), name.getString(0));
 	}
 
 	private int mkdir(MemorySegment path, int mode) {
-		return fuseOperations.mkdir(path.getUtf8String(0), mode);
+		return fuseOperations.mkdir(path.getString(0), mode);
 	}
 
 	private int open(MemorySegment path, MemorySegment fi) {
-		try (var arena = Arena.ofConfined()) {
-			return fuseOperations.open(path.getUtf8String(0), new FileInfoImpl(fi, arena));
-		}
+		return fuseOperations.open(path.getString(0), new FileInfoImpl(fi));
 	}
 
 	private int opendir(MemorySegment path, MemorySegment fi) {
-		try (var arena = Arena.ofConfined()) {
-			return fuseOperations.opendir(path.getUtf8String(0), new FileInfoImpl(fi, arena));
-		}
+		return fuseOperations.opendir(path.getString(0), new FileInfoImpl(fi));
 	}
 
 	private int read(MemorySegment path, MemorySegment buf, long size, long offset, MemorySegment fi) {
-		try (var arena = Arena.ofConfined()) {
-			var buffer = buf.reinterpret(size).asByteBuffer();
-			return fuseOperations.read(path.getUtf8String(0), buffer, size, offset, new FileInfoImpl(fi, arena));
-		}
+		var buffer = buf.reinterpret(size).asByteBuffer();
+		return fuseOperations.read(path.getString(0), buffer, size, offset, new FileInfoImpl(fi));
 	}
 
 	private int readdir(MemorySegment path, MemorySegment buf, MemorySegment filler, long offset, MemorySegment fi, int flags) {
 		try (var arena = Arena.ofConfined()) {
-			return fuseOperations.readdir(path.getUtf8String(0), new DirFillerImpl(buf, filler, arena), offset, new FileInfoImpl(fi, arena), flags);
+			return fuseOperations.readdir(path.getString(0), new DirFillerImpl(buf, filler, arena), offset, new FileInfoImpl(fi), flags);
 		}
 	}
 
 	private int readlink(MemorySegment path, MemorySegment buf, long len) {
 		var buffer = buf.reinterpret(len).asByteBuffer();
-		return fuseOperations.readlink(path.getUtf8String(0), buffer, len);
+		return fuseOperations.readlink(path.getString(0), buffer, len);
 	}
 
 	private int release(MemorySegment path, MemorySegment fi) {
-		try (var arena = Arena.ofConfined()) {
-			return fuseOperations.release(path.getUtf8String(0), new FileInfoImpl(fi, arena));
-		}
+		return fuseOperations.release(path.getString(0), new FileInfoImpl(fi));
 	}
 
 	private int releasedir(MemorySegment path, MemorySegment fi) {
-		try (var arena = Arena.ofConfined()) {
-			return fuseOperations.releasedir(MemoryUtils.toUtf8StringOrNull(path), new FileInfoImpl(fi, arena));
-		}
+		return fuseOperations.releasedir(MemoryUtils.toUtf8StringOrNull(path), new FileInfoImpl(fi));
 	}
 
 	private int rename(MemorySegment oldpath, MemorySegment newpath, int flags) {
-		return fuseOperations.rename(oldpath.getUtf8String(0), newpath.getUtf8String(0), flags);
+		return fuseOperations.rename(oldpath.getString(0), newpath.getString(0), flags);
 	}
 
 	private int rmdir(MemorySegment path) {
-		return fuseOperations.rmdir(path.getUtf8String(0));
+		return fuseOperations.rmdir(path.getString(0));
 	}
 
 	private int statfs(MemorySegment path, MemorySegment statvfs) {
-		try (var arena = Arena.ofConfined()) {
-			return fuseOperations.statfs(path.getUtf8String(0), new StatvfsImpl(statvfs, arena));
-		}
+		return fuseOperations.statfs(path.getString(0), new StatvfsImpl(statvfs));
 	}
 
 	private int symlink(MemorySegment linkname, MemorySegment target) {
-		return fuseOperations.symlink(linkname.getUtf8String(0), target.getUtf8String(0));
+		return fuseOperations.symlink(linkname.getString(0), target.getString(0));
 	}
 
 	private int truncate(MemorySegment path, long size, MemorySegment fi) {
-		try (var arena = Arena.ofConfined()) {
-			return fuseOperations.truncate(path.getUtf8String(0), size, FileInfoImpl.of(fi, arena));
-		}
+		return fuseOperations.truncate(path.getString(0), size, FileInfoImpl.ofNullable(fi));
 	}
 
 	private int unlink(MemorySegment path) {
-		return fuseOperations.unlink(path.getUtf8String(0));
+		return fuseOperations.unlink(path.getString(0));
 	}
 
 	@VisibleForTesting
@@ -267,24 +237,22 @@ int utimens(MemorySegment path, MemorySegment times, MemorySegment fi) {
 		try (var arena = Arena.ofConfined()) {
 			if (MemorySegment.NULL.equals(times)) {
 				// set both times to current time
-				var segment = arena.allocate(timespec.$LAYOUT());
-				timespec.tv_sec$set(segment, 0);
-				timespec.tv_nsec$set(segment, stat_h.UTIME_NOW());
+				var segment = timespec.allocate(arena);
+				timespec.tv_sec(segment, 0);
+				timespec.tv_nsec(segment, stat_h.UTIME_NOW());
 				var time = new TimeSpecImpl(segment);
-				return fuseOperations.utimens(path.getUtf8String(0), time, time, FileInfoImpl.of(fi, arena));
+				return fuseOperations.utimens(path.getString(0), time, time, FileInfoImpl.ofNullable(fi));
 			} else {
-				var time0 = times.asSlice(0, timespec.$LAYOUT().byteSize());
-				var time1 = times.asSlice(timespec.$LAYOUT().byteSize(), timespec.$LAYOUT().byteSize());
-				return fuseOperations.utimens(path.getUtf8String(0), new TimeSpecImpl(time0), new TimeSpecImpl(time1), FileInfoImpl.of(fi, arena));
+				var time0 = timespec.asSlice(times, 0);
+				var time1 = timespec.asSlice(times, 1);
+				return fuseOperations.utimens(path.getString(0), new TimeSpecImpl(time0), new TimeSpecImpl(time1), FileInfoImpl.ofNullable(fi));
 			}
 		}
 	}
 
 	private int write(MemorySegment path, MemorySegment buf, long size, long offset, MemorySegment fi) {
-		try (var arena = Arena.ofConfined()) {
-			var buffer = buf.reinterpret(size).asByteBuffer();
-			return fuseOperations.write(path.getUtf8String(0), buffer, size, offset, new FileInfoImpl(fi, arena));
-		}
+		var buffer = buf.reinterpret(size).asByteBuffer();
+		return fuseOperations.write(path.getString(0), buffer, size, offset, new FileInfoImpl(fi));
 	}
 
 }
\ No newline at end of file
diff --git a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/FuseMountImpl.java b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/FuseMountImpl.java
index 22bf954f..d2812e41 100644
--- a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/FuseMountImpl.java
+++ b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/FuseMountImpl.java
@@ -22,8 +22,8 @@ public int loop() {
 			// FUSE 3.2
 			try (var arena = Arena.ofConfined()) {
 				var loopCfg = fuse_loop_config_v1.allocate(arena);
-				fuse_loop_config_v1.clone_fd$set(loopCfg, fuseArgs.cloneFd());
-				fuse_loop_config_v1.max_idle_threads$set(loopCfg, fuseArgs.maxIdleThreads());
+				fuse_loop_config_v1.clone_fd(loopCfg, fuseArgs.cloneFd());
+				fuse_loop_config_v1.max_idle_threads(loopCfg, fuseArgs.maxIdleThreads());
 				return fuse_h.fuse_loop_mt(fuse, loopCfg);
 			}
 		} else {
diff --git a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/StatImpl.java b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/StatImpl.java
index 0cb34ff4..b3c86664 100644
--- a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/StatImpl.java
+++ b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/StatImpl.java
@@ -9,78 +9,74 @@
 
 record StatImpl(MemorySegment segment) implements Stat {
 
-	public StatImpl(MemorySegment address, Arena scope) {
-		this(stat.ofAddress(address, scope));
-	}
-
 	@Override
 	public TimeSpec aTime() {
-		return new TimeSpecImpl(stat.st_atim$slice(segment));
+		return new TimeSpecImpl(stat.st_atim(segment));
 	}
 
 	@Override
 	public TimeSpec cTime() {
-		return new TimeSpecImpl(stat.st_ctim$slice(segment));
+		return new TimeSpecImpl(stat.st_ctim(segment));
 	}
 
 	@Override
 	public TimeSpec mTime() {
-		return new TimeSpecImpl(stat.st_mtim$slice(segment));
+		return new TimeSpecImpl(stat.st_mtim(segment));
 	}
 
 	@Override
 	public TimeSpec birthTime() {
-		return new TimeSpecImpl(stat.st_ctim$slice(segment));
+		return new TimeSpecImpl(stat.st_ctim(segment));
 	}
 
 	@Override
 	public void setMode(int mode) {
-		stat.st_mode$set(segment, mode);
+		stat.st_mode(segment, mode);
 	}
 
 	@Override
 	public int getMode() {
-		return stat.st_mode$get(segment);
+		return stat.st_mode(segment);
 	}
 
 	@Override
 	public void setUid(int uid) {
-		stat.st_uid$set(segment, uid);
+		stat.st_uid(segment, uid);
 	}
 
 	@Override
 	public int getUid() {
-		return stat.st_uid$get(segment);
+		return stat.st_uid(segment);
 	}
 
 	@Override
 	public void setGid(int gid) {
-		stat.st_gid$set(segment, gid);
+		stat.st_gid(segment, gid);
 	}
 
 	@Override
 	public int getGid() {
-		return stat.st_gid$get(segment);
+		return stat.st_gid(segment);
 	}
 
 	@Override
 	public void setNLink(short count) {
-		stat.st_nlink$set(segment, count);
+		stat.st_nlink(segment, count);
 	}
 
 	@Override
 	public long getNLink() {
-		return stat.st_nlink$get(segment);
+		return stat.st_nlink(segment);
 	}
 
 	@Override
 	public void setSize(long size) {
-		stat.st_size$set(segment, size);
+		stat.st_size(segment, size);
 	}
 
 	@Override
 	public long getSize() {
-		return stat.st_size$get(segment);
+		return stat.st_size(segment);
 	}
 
 }
diff --git a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/StatvfsImpl.java b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/StatvfsImpl.java
index 27c54a4c..043d7a7a 100644
--- a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/StatvfsImpl.java
+++ b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/StatvfsImpl.java
@@ -8,68 +8,64 @@
 
 record StatvfsImpl(MemorySegment segment) implements Statvfs {
 
-	public StatvfsImpl(MemorySegment address, Arena scope) {
-		this(statvfs.ofAddress(address, scope));
-	}
-
 	@Override
 	public long getBsize() {
-		return statvfs.f_bsize$get(segment);
+		return statvfs.f_bsize(segment);
 	}
 
 	@Override
 	public void setBsize(long bsize) {
-		statvfs.f_bsize$set(segment, bsize);
+		statvfs.f_bsize(segment, bsize);
 	}
 
 	@Override
 	public long getFrsize() {
-		return statvfs.f_frsize$get(segment);
+		return statvfs.f_frsize(segment);
 	}
 
 	@Override
 	public void setFrsize(long frsize) {
-		statvfs.f_frsize$set(segment, frsize);
+		statvfs.f_frsize(segment, frsize);
 	}
 
 	@Override
 	public long getBlocks() {
-		return statvfs.f_blocks$get(segment);
+		return statvfs.f_blocks(segment);
 	}
 
 	@Override
 	public void setBlocks(long blocks) {
-		statvfs.f_blocks$set(segment, blocks);
+		statvfs.f_blocks(segment, blocks);
 	}
 
 	@Override
 	public long getBfree() {
-		return statvfs.f_bfree$get(segment);
+		return statvfs.f_bfree(segment);
 	}
 
 	@Override
 	public void setBfree(long bfree) {
-		statvfs.f_bfree$set(segment, bfree);
+		statvfs.f_bfree(segment, bfree);
 	}
 
 	@Override
 	public long getBavail() {
-		return statvfs.f_bavail$get(segment);
+		return statvfs.f_bavail(segment);
 	}
 
 	@Override
 	public void setBavail(long bavail) {
-		statvfs.f_bavail$set(segment, bavail);
+		statvfs.f_bavail(segment, bavail);
 	}
 
 	@Override
 	public long getNameMax() {
-		return statvfs.f_namemax$get(segment);
+		return statvfs.f_namemax(segment);
 	}
 
 	@Override
 	public void setNameMax(long namemax) {
-		statvfs.f_namemax$set(segment, namemax);
+		statvfs.f_namemax(segment, namemax);
 	}
 
 }
diff --git a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/TimeSpecImpl.java b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/TimeSpecImpl.java
index ecbd5f5e..9f6b58d2 100644
--- a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/TimeSpecImpl.java
+++ b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/TimeSpecImpl.java
@@ -11,26 +11,26 @@ record TimeSpecImpl(MemorySegment segment) implements TimeSpec {
 
 	@Override
 	public boolean isUtimeOmit() {
-		var nanos = timespec.tv_nsec$get(segment);
+		var nanos = timespec.tv_nsec(segment);
 		return stat_h.UTIME_OMIT() == nanos;
 	}
 
 	@Override
 	public boolean isUtimeNow() {
-		var nanos = timespec.tv_nsec$get(segment);
+		var nanos = timespec.tv_nsec(segment);
 		return stat_h.UTIME_NOW() == nanos;
 	}
 
 	@Override
 	public void set(Instant newValue) {
-		timespec.tv_sec$set(segment, newValue.getEpochSecond());
-		timespec.tv_nsec$set(segment, newValue.getNano());
+		timespec.tv_sec(segment, newValue.getEpochSecond());
+		timespec.tv_nsec(segment, newValue.getNano());
 	}
 
 	@Override
 	public Instant get() {
-		var seconds = timespec.tv_sec$get(segment);
-		var nanos = timespec.tv_nsec$get(segment);
+		var seconds = timespec.tv_sec(segment);
+		var nanos = timespec.tv_nsec(segment);
 		return Instant.ofEpochSecond(seconds, nanos);
 	}
 
diff --git a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/errno/RuntimeHelper.java b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/errno/RuntimeHelper.java
deleted file mode 100644
index 3125b985..00000000
--- a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/errno/RuntimeHelper.java
+++ /dev/null
@@ -1,245 +0,0 @@
-package org.cryptomator.jfuse.linux.amd64.extr.errno;
-// Generated by jextract
-
-import java.lang.foreign.Linker;
-import java.lang.foreign.FunctionDescriptor;
-import java.lang.foreign.GroupLayout;
-import java.lang.foreign.SymbolLookup;
-import java.lang.foreign.MemoryLayout;
-import java.lang.foreign.MemorySegment;
-import java.lang.foreign.Arena;
-import java.lang.foreign.SegmentAllocator;
-import java.lang.foreign.ValueLayout;
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.MethodHandles;
-import java.lang.invoke.MethodType;
-import java.io.File;
-import java.nio.file.Path;
-import java.nio.charset.StandardCharsets;
-import java.util.Arrays;
-import java.util.Optional;
-import java.util.stream.Stream;
-
-import java.lang.foreign.AddressLayout;
-import java.lang.foreign.MemoryLayout;
-
-import static java.lang.foreign.Linker.*;
-import static java.lang.foreign.ValueLayout.*;
-
-final class RuntimeHelper {
-
-    private static final Linker LINKER = Linker.nativeLinker();
-    private static final ClassLoader LOADER = RuntimeHelper.class.getClassLoader();
-    private static final MethodHandles.Lookup MH_LOOKUP = MethodHandles.lookup();
-    private static final SymbolLookup SYMBOL_LOOKUP;
-    private static final SegmentAllocator THROWING_ALLOCATOR = (x, y) -> { throw new AssertionError("should not reach here"); };
-    static final AddressLayout POINTER = ValueLayout.ADDRESS.withTargetLayout(MemoryLayout.sequenceLayout(JAVA_BYTE));
-
-    final static SegmentAllocator CONSTANT_ALLOCATOR =
-            (size, align) -> Arena.ofAuto().allocate(size, align);
-
-    static {
-        
-        SymbolLookup loaderLookup = SymbolLookup.loaderLookup();
-        SYMBOL_LOOKUP = name -> loaderLookup.find(name).or(() -> LINKER.defaultLookup().find(name));
-    }
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private RuntimeHelper() {}
-
-    static <T> T requireNonNull(T obj, String symbolName) {
-        if (obj == null) {
-            throw new UnsatisfiedLinkError("unresolved symbol: " + symbolName);
-        }
-        return obj;
-    }
-
-    static MemorySegment lookupGlobalVariable(String name, MemoryLayout layout) {
-        return SYMBOL_LOOKUP.find(name)
-                .map(s -> s.reinterpret(layout.byteSize()))
-                .orElse(null);
-    }
-
-    static MethodHandle downcallHandle(String name, FunctionDescriptor fdesc) {
-        return SYMBOL_LOOKUP.find(name).
-                map(addr -> LINKER.downcallHandle(addr, fdesc)).
-                orElse(null);
-    }
-
-    static MethodHandle downcallHandle(FunctionDescriptor fdesc) {
-        return LINKER.downcallHandle(fdesc);
-    }
-
-    static MethodHandle downcallHandleVariadic(String name, FunctionDescriptor fdesc) {
-        return SYMBOL_LOOKUP.find(name).
-                map(addr -> VarargsInvoker.make(addr, fdesc)).
-                orElse(null);
-    }
-
-    static MethodHandle upcallHandle(Class<?> fi, String name, FunctionDescriptor fdesc) {
-        try {
-            return MH_LOOKUP.findVirtual(fi, name, fdesc.toMethodType());
-        } catch (Throwable ex) {
-            throw new AssertionError(ex);
-        }
-    }
-
-    static <Z> MemorySegment upcallStub(MethodHandle fiHandle, Z z, FunctionDescriptor fdesc, Arena scope) {
-        try {
-            fiHandle = fiHandle.bindTo(z);
-            return LINKER.upcallStub(fiHandle, fdesc, scope);
-        } catch (Throwable ex) {
-            throw new AssertionError(ex);
-        }
-    }
-
-    static MemorySegment asArray(MemorySegment addr, MemoryLayout layout, int numElements, Arena arena) {
-         return addr.reinterpret(numElements * layout.byteSize(), arena, null);
-    }
-
-    // Internals only below this point
-
-    private static final class VarargsInvoker {
-        private static final MethodHandle INVOKE_MH;
-        private final MemorySegment symbol;
-        private final FunctionDescriptor function;
-
-        private VarargsInvoker(MemorySegment symbol, FunctionDescriptor function) {
-            this.symbol = symbol;
-            this.function = function;
-        }
-
-        static {
-            try {
-                INVOKE_MH = MethodHandles.lookup().findVirtual(VarargsInvoker.class, "invoke", MethodType.methodType(Object.class, SegmentAllocator.class, Object[].class));
-            } catch (ReflectiveOperationException e) {
-                throw new RuntimeException(e);
-            }
-        }
-
-        static MethodHandle make(MemorySegment symbol, FunctionDescriptor function) {
-            VarargsInvoker invoker = new VarargsInvoker(symbol, function);
-            MethodHandle handle = INVOKE_MH.bindTo(invoker).asCollector(Object[].class, function.argumentLayouts().size() + 1);
-            MethodType mtype = MethodType.methodType(function.returnLayout().isPresent() ? carrier(function.returnLayout().get(), true) : void.class);
-            for (MemoryLayout layout : function.argumentLayouts()) {
-                mtype = mtype.appendParameterTypes(carrier(layout, false));
-            }
-            mtype = mtype.appendParameterTypes(Object[].class);
-            boolean needsAllocator = function.returnLayout().isPresent() &&
-                                function.returnLayout().get() instanceof GroupLayout;
-            if (needsAllocator) {
-                mtype = mtype.insertParameterTypes(0, SegmentAllocator.class);
-            } else {
-                handle = MethodHandles.insertArguments(handle, 0, THROWING_ALLOCATOR);
-            }
-            return handle.asType(mtype);
-        }
-
-        static Class<?> carrier(MemoryLayout layout, boolean ret) {
-            if (layout instanceof ValueLayout valueLayout) {
-                return valueLayout.carrier();
-            } else if (layout instanceof GroupLayout) {
-                return MemorySegment.class;
-            } else {
-                throw new AssertionError("Cannot get here!");
-            }
-        }
-
-        private Object invoke(SegmentAllocator allocator, Object[] args) throws Throwable {
-            // one trailing Object[]
-            int nNamedArgs = function.argumentLayouts().size();
-            assert(args.length == nNamedArgs + 1);
-            // The last argument is the array of vararg collector
-            Object[] unnamedArgs = (Object[]) args[args.length - 1];
-
-            int argsCount = nNamedArgs + unnamedArgs.length;
-            Class<?>[] argTypes = new Class<?>[argsCount];
-            MemoryLayout[] argLayouts = new MemoryLayout[nNamedArgs + unnamedArgs.length];
-
-            int pos = 0;
-            for (pos = 0; pos < nNamedArgs; pos++) {
-                argLayouts[pos] = function.argumentLayouts().get(pos);
-            }
-
-            assert pos == nNamedArgs;
-            for (Object o: unnamedArgs) {
-                argLayouts[pos] = variadicLayout(normalize(o.getClass()));
-                pos++;
-            }
-            assert pos == argsCount;
-
-            FunctionDescriptor f = (function.returnLayout().isEmpty()) ?
-                    FunctionDescriptor.ofVoid(argLayouts) :
-                    FunctionDescriptor.of(function.returnLayout().get(), argLayouts);
-            MethodHandle mh = LINKER.downcallHandle(symbol, f);
-            boolean needsAllocator = function.returnLayout().isPresent() &&
-                                            function.returnLayout().get() instanceof GroupLayout;
-            if (needsAllocator) {
-                mh = mh.bindTo(allocator);
-            }
-            // flatten argument list so that it can be passed to an asSpreader MH
-            Object[] allArgs = new Object[nNamedArgs + unnamedArgs.length];
-            System.arraycopy(args, 0, allArgs, 0, nNamedArgs);
-            System.arraycopy(unnamedArgs, 0, allArgs, nNamedArgs, unnamedArgs.length);
-
-            return mh.asSpreader(Object[].class, argsCount).invoke(allArgs);
-        }
-
-        private static Class<?> unboxIfNeeded(Class<?> clazz) {
-            if (clazz == Boolean.class) {
-                return boolean.class;
-            } else if (clazz == Void.class) {
-                return void.class;
-            } else if (clazz == Byte.class) {
-                return byte.class;
-            } else if (clazz == Character.class) {
-                return char.class;
-            } else if (clazz == Short.class) {
-                return short.class;
-            } else if (clazz == Integer.class) {
-                return int.class;
-            } else if (clazz == Long.class) {
-                return long.class;
-            } else if (clazz == Float.class) {
-                return float.class;
-            } else if (clazz == Double.class) {
-                return double.class;
-            } else {
-                return clazz;
-            }
-        }
-
-        private Class<?> promote(Class<?> c) {
-            if (c == byte.class || c == char.class || c == short.class || c == int.class) {
-                return long.class;
-            } else if (c == float.class) {
-                return double.class;
-            } else {
-                return c;
-            }
-        }
-
-        private Class<?> normalize(Class<?> c) {
-            c = unboxIfNeeded(c);
-            if (c.isPrimitive()) {
-                return promote(c);
-            }
-            if (c == MemorySegment.class) {
-                return MemorySegment.class;
-            }
-            throw new IllegalArgumentException("Invalid type for ABI: " + c.getTypeName());
-        }
-
-        private MemoryLayout variadicLayout(Class<?> c) {
-            if (c == long.class) {
-                return JAVA_LONG;
-            } else if (c == double.class) {
-                return JAVA_DOUBLE;
-            } else if (c == MemorySegment.class) {
-                return ADDRESS;
-            } else {
-                throw new IllegalArgumentException("Unhandled variadic argument class: " + c);
-            }
-        }
-    }
-}
diff --git a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/errno/constants$0.java b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/errno/constants$0.java
deleted file mode 100644
index 9c6903e6..00000000
--- a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/errno/constants$0.java
+++ /dev/null
@@ -1,16 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.linux.amd64.extr.errno;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$0 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$0() {}
-}
-
-
diff --git a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/errno/errno_h.java b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/errno/errno_h.java
index 3b08531f..7e538328 100644
--- a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/errno/errno_h.java
+++ b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/errno/errno_h.java
@@ -2,165 +2,233 @@
 
 package org.cryptomator.jfuse.linux.amd64.extr.errno;
 
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
+import java.lang.invoke.*;
 import java.lang.foreign.*;
+import java.nio.ByteOrder;
+import java.util.*;
+import java.util.function.*;
+import java.util.stream.*;
+
 import static java.lang.foreign.ValueLayout.*;
-public class errno_h  {
+import static java.lang.foreign.MemoryLayout.PathElement.*;
+
+public class errno_h {
+
+    errno_h() {
+        // Should not be called directly
+    }
+
+    static final Arena LIBRARY_ARENA = Arena.ofAuto();
+    static final boolean TRACE_DOWNCALLS = Boolean.getBoolean("jextract.trace.downcalls");
+
+    static void traceDowncall(String name, Object... args) {
+         String traceArgs = Arrays.stream(args)
+                       .map(Object::toString)
+                       .collect(Collectors.joining(", "));
+         System.out.printf("%s(%s)\n", name, traceArgs);
+    }
 
-    public static final OfByte C_CHAR = JAVA_BYTE;
-    public static final OfShort C_SHORT = JAVA_SHORT;
-    public static final OfInt C_INT = JAVA_INT;
-    public static final OfLong C_LONG = JAVA_LONG;
-    public static final OfLong C_LONG_LONG = JAVA_LONG;
-    public static final OfFloat C_FLOAT = JAVA_FLOAT;
-    public static final OfDouble C_DOUBLE = JAVA_DOUBLE;
-    public static final AddressLayout C_POINTER = RuntimeHelper.POINTER;
-    /**
-     * {@snippet :
+    static MemorySegment findOrThrow(String symbol) {
+        return SYMBOL_LOOKUP.find(symbol)
+            .orElseThrow(() -> new UnsatisfiedLinkError("unresolved symbol: " + symbol));
+    }
+
+    static MethodHandle upcallHandle(Class<?> fi, String name, FunctionDescriptor fdesc) {
+        try {
+            return MethodHandles.lookup().findVirtual(fi, name, fdesc.toMethodType());
+        } catch (ReflectiveOperationException ex) {
+            throw new AssertionError(ex);
+        }
+    }
+
+    static MemoryLayout align(MemoryLayout layout, long align) {
+        return switch (layout) {
+            case PaddingLayout p -> p;
+            case ValueLayout v -> v.withByteAlignment(align);
+            case GroupLayout g -> {
+                MemoryLayout[] alignedMembers = g.memberLayouts().stream()
+                        .map(m -> align(m, align)).toArray(MemoryLayout[]::new);
+                yield g instanceof StructLayout ?
+                        MemoryLayout.structLayout(alignedMembers) : MemoryLayout.unionLayout(alignedMembers);
+            }
+            case SequenceLayout s -> MemoryLayout.sequenceLayout(s.elementCount(), align(s.elementLayout(), align));
+        };
+    }
+
+    static final SymbolLookup SYMBOL_LOOKUP = SymbolLookup.loaderLookup()
+            .or(Linker.nativeLinker().defaultLookup());
+
+    public static final ValueLayout.OfBoolean C_BOOL = ValueLayout.JAVA_BOOLEAN;
+    public static final ValueLayout.OfByte C_CHAR = ValueLayout.JAVA_BYTE;
+    public static final ValueLayout.OfShort C_SHORT = ValueLayout.JAVA_SHORT;
+    public static final ValueLayout.OfInt C_INT = ValueLayout.JAVA_INT;
+    public static final ValueLayout.OfLong C_LONG_LONG = ValueLayout.JAVA_LONG;
+    public static final ValueLayout.OfFloat C_FLOAT = ValueLayout.JAVA_FLOAT;
+    public static final ValueLayout.OfDouble C_DOUBLE = ValueLayout.JAVA_DOUBLE;
+    public static final AddressLayout C_POINTER = ValueLayout.ADDRESS
+            .withTargetLayout(MemoryLayout.sequenceLayout(java.lang.Long.MAX_VALUE, JAVA_BYTE));
+    public static final ValueLayout.OfLong C_LONG = ValueLayout.JAVA_LONG;
+    private static final int ENOENT = (int)2L;
+    /**
+     * {@snippet lang=c :
      * #define ENOENT 2
      * }
      */
     public static int ENOENT() {
-        return (int)2L;
+        return ENOENT;
     }
+    private static final int EIO = (int)5L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define EIO 5
      * }
      */
     public static int EIO() {
-        return (int)5L;
+        return EIO;
     }
+    private static final int E2BIG = (int)7L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define E2BIG 7
      * }
      */
     public static int E2BIG() {
-        return (int)7L;
+        return E2BIG;
     }
+    private static final int EBADF = (int)9L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define EBADF 9
      * }
      */
     public static int EBADF() {
-        return (int)9L;
+        return EBADF;
     }
+    private static final int ENOMEM = (int)12L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define ENOMEM 12
      * }
      */
     public static int ENOMEM() {
-        return (int)12L;
+        return ENOMEM;
     }
+    private static final int EACCES = (int)13L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define EACCES 13
      * }
      */
     public static int EACCES() {
-        return (int)13L;
+        return EACCES;
     }
+    private static final int EEXIST = (int)17L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define EEXIST 17
      * }
      */
     public static int EEXIST() {
-        return (int)17L;
+        return EEXIST;
     }
+    private static final int ENOTDIR = (int)20L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define ENOTDIR 20
      * }
      */
     public static int ENOTDIR() {
-        return (int)20L;
+        return ENOTDIR;
     }
+    private static final int EISDIR = (int)21L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define EISDIR 21
      * }
      */
     public static int EISDIR() {
-        return (int)21L;
+        return EISDIR;
     }
+    private static final int EINVAL = (int)22L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define EINVAL 22
      * }
      */
     public static int EINVAL() {
-        return (int)22L;
+        return EINVAL;
     }
+    private static final int EROFS = (int)30L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define EROFS 30
      * }
      */
     public static int EROFS() {
-        return (int)30L;
+        return EROFS;
     }
+    private static final int ERANGE = (int)34L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define ERANGE 34
      * }
      */
     public static int ERANGE() {
-        return (int)34L;
+        return ERANGE;
     }
+    private static final int ENAMETOOLONG = (int)36L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define ENAMETOOLONG 36
      * }
      */
     public static int ENAMETOOLONG() {
-        return (int)36L;
+        return ENAMETOOLONG;
     }
+    private static final int ENOLCK = (int)37L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define ENOLCK 37
      * }
      */
     public static int ENOLCK() {
-        return (int)37L;
+        return ENOLCK;
     }
+    private static final int ENOSYS = (int)38L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define ENOSYS 38
      * }
      */
     public static int ENOSYS() {
-        return (int)38L;
+        return ENOSYS;
     }
+    private static final int ENOTEMPTY = (int)39L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define ENOTEMPTY 39
      * }
      */
     public static int ENOTEMPTY() {
-        return (int)39L;
+        return ENOTEMPTY;
     }
+    private static final int ENODATA = (int)61L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define ENODATA 61
      * }
      */
     public static int ENODATA() {
-        return (int)61L;
+        return ENODATA;
     }
+    private static final int ENOTSUP = (int)95L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define ENOTSUP 95
      * }
      */
     public static int ENOTSUP() {
-        return (int)95L;
+        return ENOTSUP;
     }
 }
 
-
diff --git a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fcntl/RuntimeHelper.java b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fcntl/RuntimeHelper.java
deleted file mode 100644
index ef3f7ede..00000000
--- a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fcntl/RuntimeHelper.java
+++ /dev/null
@@ -1,245 +0,0 @@
-package org.cryptomator.jfuse.linux.amd64.extr.fcntl;
-// Generated by jextract
-
-import java.lang.foreign.Linker;
-import java.lang.foreign.FunctionDescriptor;
-import java.lang.foreign.GroupLayout;
-import java.lang.foreign.SymbolLookup;
-import java.lang.foreign.MemoryLayout;
-import java.lang.foreign.MemorySegment;
-import java.lang.foreign.Arena;
-import java.lang.foreign.SegmentAllocator;
-import java.lang.foreign.ValueLayout;
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.MethodHandles;
-import java.lang.invoke.MethodType;
-import java.io.File;
-import java.nio.file.Path;
-import java.nio.charset.StandardCharsets;
-import java.util.Arrays;
-import java.util.Optional;
-import java.util.stream.Stream;
-
-import java.lang.foreign.AddressLayout;
-import java.lang.foreign.MemoryLayout;
-
-import static java.lang.foreign.Linker.*;
-import static java.lang.foreign.ValueLayout.*;
-
-final class RuntimeHelper {
-
-    private static final Linker LINKER = Linker.nativeLinker();
-    private static final ClassLoader LOADER = RuntimeHelper.class.getClassLoader();
-    private static final MethodHandles.Lookup MH_LOOKUP = MethodHandles.lookup();
-    private static final SymbolLookup SYMBOL_LOOKUP;
-    private static final SegmentAllocator THROWING_ALLOCATOR = (x, y) -> { throw new AssertionError("should not reach here"); };
-    static final AddressLayout POINTER = ValueLayout.ADDRESS.withTargetLayout(MemoryLayout.sequenceLayout(JAVA_BYTE));
-
-    final static SegmentAllocator CONSTANT_ALLOCATOR =
-            (size, align) -> Arena.ofAuto().allocate(size, align);
-
-    static {
-        
-        SymbolLookup loaderLookup = SymbolLookup.loaderLookup();
-        SYMBOL_LOOKUP = name -> loaderLookup.find(name).or(() -> LINKER.defaultLookup().find(name));
-    }
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private RuntimeHelper() {}
-
-    static <T> T requireNonNull(T obj, String symbolName) {
-        if (obj == null) {
-            throw new UnsatisfiedLinkError("unresolved symbol: " + symbolName);
-        }
-        return obj;
-    }
-
-    static MemorySegment lookupGlobalVariable(String name, MemoryLayout layout) {
-        return SYMBOL_LOOKUP.find(name)
-                .map(s -> s.reinterpret(layout.byteSize()))
-                .orElse(null);
-    }
-
-    static MethodHandle downcallHandle(String name, FunctionDescriptor fdesc) {
-        return SYMBOL_LOOKUP.find(name).
-                map(addr -> LINKER.downcallHandle(addr, fdesc)).
-                orElse(null);
-    }
-
-    static MethodHandle downcallHandle(FunctionDescriptor fdesc) {
-        return LINKER.downcallHandle(fdesc);
-    }
-
-    static MethodHandle downcallHandleVariadic(String name, FunctionDescriptor fdesc) {
-        return SYMBOL_LOOKUP.find(name).
-                map(addr -> VarargsInvoker.make(addr, fdesc)).
-                orElse(null);
-    }
-
-    static MethodHandle upcallHandle(Class<?> fi, String name, FunctionDescriptor fdesc) {
-        try {
-            return MH_LOOKUP.findVirtual(fi, name, fdesc.toMethodType());
-        } catch (Throwable ex) {
-            throw new AssertionError(ex);
-        }
-    }
-
-    static <Z> MemorySegment upcallStub(MethodHandle fiHandle, Z z, FunctionDescriptor fdesc, Arena scope) {
-        try {
-            fiHandle = fiHandle.bindTo(z);
-            return LINKER.upcallStub(fiHandle, fdesc, scope);
-        } catch (Throwable ex) {
-            throw new AssertionError(ex);
-        }
-    }
-
-    static MemorySegment asArray(MemorySegment addr, MemoryLayout layout, int numElements, Arena arena) {
-         return addr.reinterpret(numElements * layout.byteSize(), arena, null);
-    }
-
-    // Internals only below this point
-
-    private static final class VarargsInvoker {
-        private static final MethodHandle INVOKE_MH;
-        private final MemorySegment symbol;
-        private final FunctionDescriptor function;
-
-        private VarargsInvoker(MemorySegment symbol, FunctionDescriptor function) {
-            this.symbol = symbol;
-            this.function = function;
-        }
-
-        static {
-            try {
-                INVOKE_MH = MethodHandles.lookup().findVirtual(VarargsInvoker.class, "invoke", MethodType.methodType(Object.class, SegmentAllocator.class, Object[].class));
-            } catch (ReflectiveOperationException e) {
-                throw new RuntimeException(e);
-            }
-        }
-
-        static MethodHandle make(MemorySegment symbol, FunctionDescriptor function) {
-            VarargsInvoker invoker = new VarargsInvoker(symbol, function);
-            MethodHandle handle = INVOKE_MH.bindTo(invoker).asCollector(Object[].class, function.argumentLayouts().size() + 1);
-            MethodType mtype = MethodType.methodType(function.returnLayout().isPresent() ? carrier(function.returnLayout().get(), true) : void.class);
-            for (MemoryLayout layout : function.argumentLayouts()) {
-                mtype = mtype.appendParameterTypes(carrier(layout, false));
-            }
-            mtype = mtype.appendParameterTypes(Object[].class);
-            boolean needsAllocator = function.returnLayout().isPresent() &&
-                                function.returnLayout().get() instanceof GroupLayout;
-            if (needsAllocator) {
-                mtype = mtype.insertParameterTypes(0, SegmentAllocator.class);
-            } else {
-                handle = MethodHandles.insertArguments(handle, 0, THROWING_ALLOCATOR);
-            }
-            return handle.asType(mtype);
-        }
-
-        static Class<?> carrier(MemoryLayout layout, boolean ret) {
-            if (layout instanceof ValueLayout valueLayout) {
-                return valueLayout.carrier();
-            } else if (layout instanceof GroupLayout) {
-                return MemorySegment.class;
-            } else {
-                throw new AssertionError("Cannot get here!");
-            }
-        }
-
-        private Object invoke(SegmentAllocator allocator, Object[] args) throws Throwable {
-            // one trailing Object[]
-            int nNamedArgs = function.argumentLayouts().size();
-            assert(args.length == nNamedArgs + 1);
-            // The last argument is the array of vararg collector
-            Object[] unnamedArgs = (Object[]) args[args.length - 1];
-
-            int argsCount = nNamedArgs + unnamedArgs.length;
-            Class<?>[] argTypes = new Class<?>[argsCount];
-            MemoryLayout[] argLayouts = new MemoryLayout[nNamedArgs + unnamedArgs.length];
-
-            int pos = 0;
-            for (pos = 0; pos < nNamedArgs; pos++) {
-                argLayouts[pos] = function.argumentLayouts().get(pos);
-            }
-
-            assert pos == nNamedArgs;
-            for (Object o: unnamedArgs) {
-                argLayouts[pos] = variadicLayout(normalize(o.getClass()));
-                pos++;
-            }
-            assert pos == argsCount;
-
-            FunctionDescriptor f = (function.returnLayout().isEmpty()) ?
-                    FunctionDescriptor.ofVoid(argLayouts) :
-                    FunctionDescriptor.of(function.returnLayout().get(), argLayouts);
-            MethodHandle mh = LINKER.downcallHandle(symbol, f);
-            boolean needsAllocator = function.returnLayout().isPresent() &&
-                                            function.returnLayout().get() instanceof GroupLayout;
-            if (needsAllocator) {
-                mh = mh.bindTo(allocator);
-            }
-            // flatten argument list so that it can be passed to an asSpreader MH
-            Object[] allArgs = new Object[nNamedArgs + unnamedArgs.length];
-            System.arraycopy(args, 0, allArgs, 0, nNamedArgs);
-            System.arraycopy(unnamedArgs, 0, allArgs, nNamedArgs, unnamedArgs.length);
-
-            return mh.asSpreader(Object[].class, argsCount).invoke(allArgs);
-        }
-
-        private static Class<?> unboxIfNeeded(Class<?> clazz) {
-            if (clazz == Boolean.class) {
-                return boolean.class;
-            } else if (clazz == Void.class) {
-                return void.class;
-            } else if (clazz == Byte.class) {
-                return byte.class;
-            } else if (clazz == Character.class) {
-                return char.class;
-            } else if (clazz == Short.class) {
-                return short.class;
-            } else if (clazz == Integer.class) {
-                return int.class;
-            } else if (clazz == Long.class) {
-                return long.class;
-            } else if (clazz == Float.class) {
-                return float.class;
-            } else if (clazz == Double.class) {
-                return double.class;
-            } else {
-                return clazz;
-            }
-        }
-
-        private Class<?> promote(Class<?> c) {
-            if (c == byte.class || c == char.class || c == short.class || c == int.class) {
-                return long.class;
-            } else if (c == float.class) {
-                return double.class;
-            } else {
-                return c;
-            }
-        }
-
-        private Class<?> normalize(Class<?> c) {
-            c = unboxIfNeeded(c);
-            if (c.isPrimitive()) {
-                return promote(c);
-            }
-            if (c == MemorySegment.class) {
-                return MemorySegment.class;
-            }
-            throw new IllegalArgumentException("Invalid type for ABI: " + c.getTypeName());
-        }
-
-        private MemoryLayout variadicLayout(Class<?> c) {
-            if (c == long.class) {
-                return JAVA_LONG;
-            } else if (c == double.class) {
-                return JAVA_DOUBLE;
-            } else if (c == MemorySegment.class) {
-                return ADDRESS;
-            } else {
-                throw new IllegalArgumentException("Unhandled variadic argument class: " + c);
-            }
-        }
-    }
-}
diff --git a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fcntl/constants$0.java b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fcntl/constants$0.java
deleted file mode 100644
index e37d6684..00000000
--- a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fcntl/constants$0.java
+++ /dev/null
@@ -1,16 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.linux.amd64.extr.fcntl;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$0 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$0() {}
-}
-
-
diff --git a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fcntl/fcntl_h.java b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fcntl/fcntl_h.java
index 021214e9..105fbf64 100644
--- a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fcntl/fcntl_h.java
+++ b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fcntl/fcntl_h.java
@@ -2,93 +2,152 @@
 
 package org.cryptomator.jfuse.linux.amd64.extr.fcntl;
 
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
+import java.lang.invoke.*;
 import java.lang.foreign.*;
+import java.nio.ByteOrder;
+import java.util.*;
+import java.util.function.*;
+import java.util.stream.*;
+
 import static java.lang.foreign.ValueLayout.*;
-public class fcntl_h  {
+import static java.lang.foreign.MemoryLayout.PathElement.*;
+
+public class fcntl_h {
+
+    fcntl_h() {
+        // Should not be called directly
+    }
+
+    static final Arena LIBRARY_ARENA = Arena.ofAuto();
+    static final boolean TRACE_DOWNCALLS = Boolean.getBoolean("jextract.trace.downcalls");
+
+    static void traceDowncall(String name, Object... args) {
+         String traceArgs = Arrays.stream(args)
+                       .map(Object::toString)
+                       .collect(Collectors.joining(", "));
+         System.out.printf("%s(%s)\n", name, traceArgs);
+    }
 
-    public static final OfByte C_CHAR = JAVA_BYTE;
-    public static final OfShort C_SHORT = JAVA_SHORT;
-    public static final OfInt C_INT = JAVA_INT;
-    public static final OfLong C_LONG = JAVA_LONG;
-    public static final OfLong C_LONG_LONG = JAVA_LONG;
-    public static final OfFloat C_FLOAT = JAVA_FLOAT;
-    public static final OfDouble C_DOUBLE = JAVA_DOUBLE;
-    public static final AddressLayout C_POINTER = RuntimeHelper.POINTER;
+    static MemorySegment findOrThrow(String symbol) {
+        return SYMBOL_LOOKUP.find(symbol)
+            .orElseThrow(() -> new UnsatisfiedLinkError("unresolved symbol: " + symbol));
+    }
+
+    static MethodHandle upcallHandle(Class<?> fi, String name, FunctionDescriptor fdesc) {
+        try {
+            return MethodHandles.lookup().findVirtual(fi, name, fdesc.toMethodType());
+        } catch (ReflectiveOperationException ex) {
+            throw new AssertionError(ex);
+        }
+    }
+
+    static MemoryLayout align(MemoryLayout layout, long align) {
+        return switch (layout) {
+            case PaddingLayout p -> p;
+            case ValueLayout v -> v.withByteAlignment(align);
+            case GroupLayout g -> {
+                MemoryLayout[] alignedMembers = g.memberLayouts().stream()
+                        .map(m -> align(m, align)).toArray(MemoryLayout[]::new);
+                yield g instanceof StructLayout ?
+                        MemoryLayout.structLayout(alignedMembers) : MemoryLayout.unionLayout(alignedMembers);
+            }
+            case SequenceLayout s -> MemoryLayout.sequenceLayout(s.elementCount(), align(s.elementLayout(), align));
+        };
+    }
+
+    static final SymbolLookup SYMBOL_LOOKUP = SymbolLookup.loaderLookup()
+            .or(Linker.nativeLinker().defaultLookup());
+
+    public static final ValueLayout.OfBoolean C_BOOL = ValueLayout.JAVA_BOOLEAN;
+    public static final ValueLayout.OfByte C_CHAR = ValueLayout.JAVA_BYTE;
+    public static final ValueLayout.OfShort C_SHORT = ValueLayout.JAVA_SHORT;
+    public static final ValueLayout.OfInt C_INT = ValueLayout.JAVA_INT;
+    public static final ValueLayout.OfLong C_LONG_LONG = ValueLayout.JAVA_LONG;
+    public static final ValueLayout.OfFloat C_FLOAT = ValueLayout.JAVA_FLOAT;
+    public static final ValueLayout.OfDouble C_DOUBLE = ValueLayout.JAVA_DOUBLE;
+    public static final AddressLayout C_POINTER = ValueLayout.ADDRESS
+            .withTargetLayout(MemoryLayout.sequenceLayout(java.lang.Long.MAX_VALUE, JAVA_BYTE));
+    public static final ValueLayout.OfLong C_LONG = ValueLayout.JAVA_LONG;
+    private static final int O_RDONLY = (int)0L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define O_RDONLY 0
      * }
      */
     public static int O_RDONLY() {
-        return (int)0L;
+        return O_RDONLY;
     }
+    private static final int O_WRONLY = (int)1L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define O_WRONLY 1
      * }
      */
     public static int O_WRONLY() {
-        return (int)1L;
+        return O_WRONLY;
     }
+    private static final int O_RDWR = (int)2L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define O_RDWR 2
      * }
      */
     public static int O_RDWR() {
-        return (int)2L;
+        return O_RDWR;
     }
+    private static final int O_CREAT = (int)64L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define O_CREAT 64
      * }
      */
     public static int O_CREAT() {
-        return (int)64L;
+        return O_CREAT;
     }
+    private static final int O_EXCL = (int)128L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define O_EXCL 128
      * }
      */
     public static int O_EXCL() {
-        return (int)128L;
+        return O_EXCL;
     }
+    private static final int O_TRUNC = (int)512L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define O_TRUNC 512
      * }
      */
     public static int O_TRUNC() {
-        return (int)512L;
+        return O_TRUNC;
     }
+    private static final int O_APPEND = (int)1024L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define O_APPEND 1024
      * }
      */
     public static int O_APPEND() {
-        return (int)1024L;
+        return O_APPEND;
     }
+    private static final int O_SYNC = (int)1052672L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define O_SYNC 1052672
      * }
      */
     public static int O_SYNC() {
-        return (int)1052672L;
+        return O_SYNC;
     }
+    private static final int O_DSYNC = (int)4096L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define O_DSYNC 4096
      * }
      */
     public static int O_DSYNC() {
-        return (int)4096L;
+        return O_DSYNC;
     }
 }
 
-
diff --git a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/RuntimeHelper.java b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/RuntimeHelper.java
deleted file mode 100644
index e2850da1..00000000
--- a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/RuntimeHelper.java
+++ /dev/null
@@ -1,245 +0,0 @@
-package org.cryptomator.jfuse.linux.amd64.extr.fuse3;
-// Generated by jextract
-
-import java.lang.foreign.Linker;
-import java.lang.foreign.FunctionDescriptor;
-import java.lang.foreign.GroupLayout;
-import java.lang.foreign.SymbolLookup;
-import java.lang.foreign.MemoryLayout;
-import java.lang.foreign.MemorySegment;
-import java.lang.foreign.Arena;
-import java.lang.foreign.SegmentAllocator;
-import java.lang.foreign.ValueLayout;
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.MethodHandles;
-import java.lang.invoke.MethodType;
-import java.io.File;
-import java.nio.file.Path;
-import java.nio.charset.StandardCharsets;
-import java.util.Arrays;
-import java.util.Optional;
-import java.util.stream.Stream;
-
-import java.lang.foreign.AddressLayout;
-import java.lang.foreign.MemoryLayout;
-
-import static java.lang.foreign.Linker.*;
-import static java.lang.foreign.ValueLayout.*;
-
-final class RuntimeHelper {
-
-    private static final Linker LINKER = Linker.nativeLinker();
-    private static final ClassLoader LOADER = RuntimeHelper.class.getClassLoader();
-    private static final MethodHandles.Lookup MH_LOOKUP = MethodHandles.lookup();
-    private static final SymbolLookup SYMBOL_LOOKUP;
-    private static final SegmentAllocator THROWING_ALLOCATOR = (x, y) -> { throw new AssertionError("should not reach here"); };
-    static final AddressLayout POINTER = ValueLayout.ADDRESS.withTargetLayout(MemoryLayout.sequenceLayout(JAVA_BYTE));
-
-    final static SegmentAllocator CONSTANT_ALLOCATOR =
-            (size, align) -> Arena.ofAuto().allocate(size, align);
-
-    static {
-        
-        SymbolLookup loaderLookup = SymbolLookup.loaderLookup();
-        SYMBOL_LOOKUP = name -> loaderLookup.find(name).or(() -> LINKER.defaultLookup().find(name));
-    }
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private RuntimeHelper() {}
-
-    static <T> T requireNonNull(T obj, String symbolName) {
-        if (obj == null) {
-            throw new UnsatisfiedLinkError("unresolved symbol: " + symbolName);
-        }
-        return obj;
-    }
-
-    static MemorySegment lookupGlobalVariable(String name, MemoryLayout layout) {
-        return SYMBOL_LOOKUP.find(name)
-                .map(s -> s.reinterpret(layout.byteSize()))
-                .orElse(null);
-    }
-
-    static MethodHandle downcallHandle(String name, FunctionDescriptor fdesc) {
-        return SYMBOL_LOOKUP.find(name).
-                map(addr -> LINKER.downcallHandle(addr, fdesc)).
-                orElse(null);
-    }
-
-    static MethodHandle downcallHandle(FunctionDescriptor fdesc) {
-        return LINKER.downcallHandle(fdesc);
-    }
-
-    static MethodHandle downcallHandleVariadic(String name, FunctionDescriptor fdesc) {
-        return SYMBOL_LOOKUP.find(name).
-                map(addr -> VarargsInvoker.make(addr, fdesc)).
-                orElse(null);
-    }
-
-    static MethodHandle upcallHandle(Class<?> fi, String name, FunctionDescriptor fdesc) {
-        try {
-            return MH_LOOKUP.findVirtual(fi, name, fdesc.toMethodType());
-        } catch (Throwable ex) {
-            throw new AssertionError(ex);
-        }
-    }
-
-    static <Z> MemorySegment upcallStub(MethodHandle fiHandle, Z z, FunctionDescriptor fdesc, Arena scope) {
-        try {
-            fiHandle = fiHandle.bindTo(z);
-            return LINKER.upcallStub(fiHandle, fdesc, scope);
-        } catch (Throwable ex) {
-            throw new AssertionError(ex);
-        }
-    }
-
-    static MemorySegment asArray(MemorySegment addr, MemoryLayout layout, int numElements, Arena arena) {
-         return addr.reinterpret(numElements * layout.byteSize(), arena, null);
-    }
-
-    // Internals only below this point
-
-    private static final class VarargsInvoker {
-        private static final MethodHandle INVOKE_MH;
-        private final MemorySegment symbol;
-        private final FunctionDescriptor function;
-
-        private VarargsInvoker(MemorySegment symbol, FunctionDescriptor function) {
-            this.symbol = symbol;
-            this.function = function;
-        }
-
-        static {
-            try {
-                INVOKE_MH = MethodHandles.lookup().findVirtual(VarargsInvoker.class, "invoke", MethodType.methodType(Object.class, SegmentAllocator.class, Object[].class));
-            } catch (ReflectiveOperationException e) {
-                throw new RuntimeException(e);
-            }
-        }
-
-        static MethodHandle make(MemorySegment symbol, FunctionDescriptor function) {
-            VarargsInvoker invoker = new VarargsInvoker(symbol, function);
-            MethodHandle handle = INVOKE_MH.bindTo(invoker).asCollector(Object[].class, function.argumentLayouts().size() + 1);
-            MethodType mtype = MethodType.methodType(function.returnLayout().isPresent() ? carrier(function.returnLayout().get(), true) : void.class);
-            for (MemoryLayout layout : function.argumentLayouts()) {
-                mtype = mtype.appendParameterTypes(carrier(layout, false));
-            }
-            mtype = mtype.appendParameterTypes(Object[].class);
-            boolean needsAllocator = function.returnLayout().isPresent() &&
-                                function.returnLayout().get() instanceof GroupLayout;
-            if (needsAllocator) {
-                mtype = mtype.insertParameterTypes(0, SegmentAllocator.class);
-            } else {
-                handle = MethodHandles.insertArguments(handle, 0, THROWING_ALLOCATOR);
-            }
-            return handle.asType(mtype);
-        }
-
-        static Class<?> carrier(MemoryLayout layout, boolean ret) {
-            if (layout instanceof ValueLayout valueLayout) {
-                return valueLayout.carrier();
-            } else if (layout instanceof GroupLayout) {
-                return MemorySegment.class;
-            } else {
-                throw new AssertionError("Cannot get here!");
-            }
-        }
-
-        private Object invoke(SegmentAllocator allocator, Object[] args) throws Throwable {
-            // one trailing Object[]
-            int nNamedArgs = function.argumentLayouts().size();
-            assert(args.length == nNamedArgs + 1);
-            // The last argument is the array of vararg collector
-            Object[] unnamedArgs = (Object[]) args[args.length - 1];
-
-            int argsCount = nNamedArgs + unnamedArgs.length;
-            Class<?>[] argTypes = new Class<?>[argsCount];
-            MemoryLayout[] argLayouts = new MemoryLayout[nNamedArgs + unnamedArgs.length];
-
-            int pos = 0;
-            for (pos = 0; pos < nNamedArgs; pos++) {
-                argLayouts[pos] = function.argumentLayouts().get(pos);
-            }
-
-            assert pos == nNamedArgs;
-            for (Object o: unnamedArgs) {
-                argLayouts[pos] = variadicLayout(normalize(o.getClass()));
-                pos++;
-            }
-            assert pos == argsCount;
-
-            FunctionDescriptor f = (function.returnLayout().isEmpty()) ?
-                    FunctionDescriptor.ofVoid(argLayouts) :
-                    FunctionDescriptor.of(function.returnLayout().get(), argLayouts);
-            MethodHandle mh = LINKER.downcallHandle(symbol, f);
-            boolean needsAllocator = function.returnLayout().isPresent() &&
-                                            function.returnLayout().get() instanceof GroupLayout;
-            if (needsAllocator) {
-                mh = mh.bindTo(allocator);
-            }
-            // flatten argument list so that it can be passed to an asSpreader MH
-            Object[] allArgs = new Object[nNamedArgs + unnamedArgs.length];
-            System.arraycopy(args, 0, allArgs, 0, nNamedArgs);
-            System.arraycopy(unnamedArgs, 0, allArgs, nNamedArgs, unnamedArgs.length);
-
-            return mh.asSpreader(Object[].class, argsCount).invoke(allArgs);
-        }
-
-        private static Class<?> unboxIfNeeded(Class<?> clazz) {
-            if (clazz == Boolean.class) {
-                return boolean.class;
-            } else if (clazz == Void.class) {
-                return void.class;
-            } else if (clazz == Byte.class) {
-                return byte.class;
-            } else if (clazz == Character.class) {
-                return char.class;
-            } else if (clazz == Short.class) {
-                return short.class;
-            } else if (clazz == Integer.class) {
-                return int.class;
-            } else if (clazz == Long.class) {
-                return long.class;
-            } else if (clazz == Float.class) {
-                return float.class;
-            } else if (clazz == Double.class) {
-                return double.class;
-            } else {
-                return clazz;
-            }
-        }
-
-        private Class<?> promote(Class<?> c) {
-            if (c == byte.class || c == char.class || c == short.class || c == int.class) {
-                return long.class;
-            } else if (c == float.class) {
-                return double.class;
-            } else {
-                return c;
-            }
-        }
-
-        private Class<?> normalize(Class<?> c) {
-            c = unboxIfNeeded(c);
-            if (c.isPrimitive()) {
-                return promote(c);
-            }
-            if (c == MemorySegment.class) {
-                return MemorySegment.class;
-            }
-            throw new IllegalArgumentException("Invalid type for ABI: " + c.getTypeName());
-        }
-
-        private MemoryLayout variadicLayout(Class<?> c) {
-            if (c == long.class) {
-                return JAVA_LONG;
-            } else if (c == double.class) {
-                return JAVA_DOUBLE;
-            } else if (c == MemorySegment.class) {
-                return ADDRESS;
-            } else {
-                throw new IllegalArgumentException("Unhandled variadic argument class: " + c);
-            }
-        }
-    }
-}
diff --git a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$0.java b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$0.java
deleted file mode 100644
index c9669cf4..00000000
--- a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$0.java
+++ /dev/null
@@ -1,31 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.linux.amd64.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$0 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$0() {}
-    static final StructLayout const$0 = MemoryLayout.structLayout(
-        JAVA_INT.withName("argc"),
-        MemoryLayout.paddingLayout(4),
-        RuntimeHelper.POINTER.withName("argv"),
-        JAVA_INT.withName("allocated"),
-        MemoryLayout.paddingLayout(4)
-    ).withName("fuse_args");
-    static final VarHandle const$1 = constants$0.const$0.varHandle(MemoryLayout.PathElement.groupElement("argc"));
-    static final VarHandle const$2 = constants$0.const$0.varHandle(MemoryLayout.PathElement.groupElement("argv"));
-    static final VarHandle const$3 = constants$0.const$0.varHandle(MemoryLayout.PathElement.groupElement("allocated"));
-    static final StructLayout const$4 = MemoryLayout.structLayout(
-        JAVA_LONG.withName("tv_sec"),
-        JAVA_LONG.withName("tv_nsec")
-    ).withName("timespec");
-    static final VarHandle const$5 = constants$0.const$4.varHandle(MemoryLayout.PathElement.groupElement("tv_sec"));
-}
-
-
diff --git a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$1.java b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$1.java
deleted file mode 100644
index 35a52a80..00000000
--- a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$1.java
+++ /dev/null
@@ -1,29 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.linux.amd64.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$1 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$1() {}
-    static final VarHandle const$0 = constants$0.const$4.varHandle(MemoryLayout.PathElement.groupElement("tv_nsec"));
-    static final StructLayout const$1 = MemoryLayout.structLayout(
-        JAVA_INT.withName("flags"),
-        MemoryLayout.paddingLayout(12),
-        JAVA_LONG.withName("fh"),
-        JAVA_LONG.withName("lock_owner"),
-        JAVA_INT.withName("poll_events"),
-        MemoryLayout.paddingLayout(4)
-    ).withName("fuse_file_info");
-    static final VarHandle const$2 = constants$1.const$1.varHandle(MemoryLayout.PathElement.groupElement("flags"));
-    static final VarHandle const$3 = constants$1.const$1.varHandle(MemoryLayout.PathElement.groupElement("fh"));
-    static final VarHandle const$4 = constants$1.const$1.varHandle(MemoryLayout.PathElement.groupElement("lock_owner"));
-    static final VarHandle const$5 = constants$1.const$1.varHandle(MemoryLayout.PathElement.groupElement("poll_events"));
-}
-
-
diff --git a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$10.java b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$10.java
deleted file mode 100644
index 03b5bfde..00000000
--- a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$10.java
+++ /dev/null
@@ -1,52 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.linux.amd64.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$10 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$10() {}
-    static final MethodHandle const$0 = RuntimeHelper.upcallHandle(fuse_fill_dir_t.class, "apply", constants$9.const$5);
-    static final MethodHandle const$1 = RuntimeHelper.downcallHandle(
-        constants$9.const$5
-    );
-    static final StructLayout const$2 = MemoryLayout.structLayout(
-        JAVA_INT.withName("set_gid"),
-        JAVA_INT.withName("gid"),
-        JAVA_INT.withName("set_uid"),
-        JAVA_INT.withName("uid"),
-        JAVA_INT.withName("set_mode"),
-        JAVA_INT.withName("umask"),
-        JAVA_DOUBLE.withName("entry_timeout"),
-        JAVA_DOUBLE.withName("negative_timeout"),
-        JAVA_DOUBLE.withName("attr_timeout"),
-        JAVA_INT.withName("intr"),
-        JAVA_INT.withName("intr_signal"),
-        JAVA_INT.withName("remember"),
-        JAVA_INT.withName("hard_remove"),
-        JAVA_INT.withName("use_ino"),
-        JAVA_INT.withName("readdir_ino"),
-        JAVA_INT.withName("direct_io"),
-        JAVA_INT.withName("kernel_cache"),
-        JAVA_INT.withName("auto_cache"),
-        JAVA_INT.withName("no_rofd_flush"),
-        JAVA_INT.withName("ac_attr_timeout_set"),
-        MemoryLayout.paddingLayout(4),
-        JAVA_DOUBLE.withName("ac_attr_timeout"),
-        JAVA_INT.withName("nullpath_ok"),
-        JAVA_INT.withName("show_help"),
-        RuntimeHelper.POINTER.withName("modules"),
-        JAVA_INT.withName("debug"),
-        MemoryLayout.paddingLayout(4)
-    ).withName("fuse_config");
-    static final VarHandle const$3 = constants$10.const$2.varHandle(MemoryLayout.PathElement.groupElement("set_gid"));
-    static final VarHandle const$4 = constants$10.const$2.varHandle(MemoryLayout.PathElement.groupElement("gid"));
-    static final VarHandle const$5 = constants$10.const$2.varHandle(MemoryLayout.PathElement.groupElement("set_uid"));
-}
-
-
diff --git a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$11.java b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$11.java
deleted file mode 100644
index f3aabb71..00000000
--- a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$11.java
+++ /dev/null
@@ -1,22 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.linux.amd64.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$11 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$11() {}
-    static final VarHandle const$0 = constants$10.const$2.varHandle(MemoryLayout.PathElement.groupElement("uid"));
-    static final VarHandle const$1 = constants$10.const$2.varHandle(MemoryLayout.PathElement.groupElement("set_mode"));
-    static final VarHandle const$2 = constants$10.const$2.varHandle(MemoryLayout.PathElement.groupElement("umask"));
-    static final VarHandle const$3 = constants$10.const$2.varHandle(MemoryLayout.PathElement.groupElement("entry_timeout"));
-    static final VarHandle const$4 = constants$10.const$2.varHandle(MemoryLayout.PathElement.groupElement("negative_timeout"));
-    static final VarHandle const$5 = constants$10.const$2.varHandle(MemoryLayout.PathElement.groupElement("attr_timeout"));
-}
-
-
diff --git a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$12.java b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$12.java
deleted file mode 100644
index 0a37088e..00000000
--- a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$12.java
+++ /dev/null
@@ -1,22 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.linux.amd64.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$12 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$12() {}
-    static final VarHandle const$0 = constants$10.const$2.varHandle(MemoryLayout.PathElement.groupElement("intr"));
-    static final VarHandle const$1 = constants$10.const$2.varHandle(MemoryLayout.PathElement.groupElement("intr_signal"));
-    static final VarHandle const$2 = constants$10.const$2.varHandle(MemoryLayout.PathElement.groupElement("remember"));
-    static final VarHandle const$3 = constants$10.const$2.varHandle(MemoryLayout.PathElement.groupElement("hard_remove"));
-    static final VarHandle const$4 = constants$10.const$2.varHandle(MemoryLayout.PathElement.groupElement("use_ino"));
-    static final VarHandle const$5 = constants$10.const$2.varHandle(MemoryLayout.PathElement.groupElement("readdir_ino"));
-}
-
-
diff --git a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$13.java b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$13.java
deleted file mode 100644
index f45c8842..00000000
--- a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$13.java
+++ /dev/null
@@ -1,22 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.linux.amd64.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$13 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$13() {}
-    static final VarHandle const$0 = constants$10.const$2.varHandle(MemoryLayout.PathElement.groupElement("direct_io"));
-    static final VarHandle const$1 = constants$10.const$2.varHandle(MemoryLayout.PathElement.groupElement("kernel_cache"));
-    static final VarHandle const$2 = constants$10.const$2.varHandle(MemoryLayout.PathElement.groupElement("auto_cache"));
-    static final VarHandle const$3 = constants$10.const$2.varHandle(MemoryLayout.PathElement.groupElement("no_rofd_flush"));
-    static final VarHandle const$4 = constants$10.const$2.varHandle(MemoryLayout.PathElement.groupElement("ac_attr_timeout_set"));
-    static final VarHandle const$5 = constants$10.const$2.varHandle(MemoryLayout.PathElement.groupElement("ac_attr_timeout"));
-}
-
-
diff --git a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$14.java b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$14.java
deleted file mode 100644
index e7fc4933..00000000
--- a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$14.java
+++ /dev/null
@@ -1,69 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.linux.amd64.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$14 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$14() {}
-    static final VarHandle const$0 = constants$10.const$2.varHandle(MemoryLayout.PathElement.groupElement("nullpath_ok"));
-    static final VarHandle const$1 = constants$10.const$2.varHandle(MemoryLayout.PathElement.groupElement("show_help"));
-    static final VarHandle const$2 = constants$10.const$2.varHandle(MemoryLayout.PathElement.groupElement("modules"));
-    static final VarHandle const$3 = constants$10.const$2.varHandle(MemoryLayout.PathElement.groupElement("debug"));
-    static final StructLayout const$4 = MemoryLayout.structLayout(
-        RuntimeHelper.POINTER.withName("getattr"),
-        RuntimeHelper.POINTER.withName("readlink"),
-        RuntimeHelper.POINTER.withName("mknod"),
-        RuntimeHelper.POINTER.withName("mkdir"),
-        RuntimeHelper.POINTER.withName("unlink"),
-        RuntimeHelper.POINTER.withName("rmdir"),
-        RuntimeHelper.POINTER.withName("symlink"),
-        RuntimeHelper.POINTER.withName("rename"),
-        RuntimeHelper.POINTER.withName("link"),
-        RuntimeHelper.POINTER.withName("chmod"),
-        RuntimeHelper.POINTER.withName("chown"),
-        RuntimeHelper.POINTER.withName("truncate"),
-        RuntimeHelper.POINTER.withName("open"),
-        RuntimeHelper.POINTER.withName("read"),
-        RuntimeHelper.POINTER.withName("write"),
-        RuntimeHelper.POINTER.withName("statfs"),
-        RuntimeHelper.POINTER.withName("flush"),
-        RuntimeHelper.POINTER.withName("release"),
-        RuntimeHelper.POINTER.withName("fsync"),
-        RuntimeHelper.POINTER.withName("setxattr"),
-        RuntimeHelper.POINTER.withName("getxattr"),
-        RuntimeHelper.POINTER.withName("listxattr"),
-        RuntimeHelper.POINTER.withName("removexattr"),
-        RuntimeHelper.POINTER.withName("opendir"),
-        RuntimeHelper.POINTER.withName("readdir"),
-        RuntimeHelper.POINTER.withName("releasedir"),
-        RuntimeHelper.POINTER.withName("fsyncdir"),
-        RuntimeHelper.POINTER.withName("init"),
-        RuntimeHelper.POINTER.withName("destroy"),
-        RuntimeHelper.POINTER.withName("access"),
-        RuntimeHelper.POINTER.withName("create"),
-        RuntimeHelper.POINTER.withName("lock"),
-        RuntimeHelper.POINTER.withName("utimens"),
-        RuntimeHelper.POINTER.withName("bmap"),
-        RuntimeHelper.POINTER.withName("ioctl"),
-        RuntimeHelper.POINTER.withName("poll"),
-        RuntimeHelper.POINTER.withName("write_buf"),
-        RuntimeHelper.POINTER.withName("read_buf"),
-        RuntimeHelper.POINTER.withName("flock"),
-        RuntimeHelper.POINTER.withName("fallocate"),
-        RuntimeHelper.POINTER.withName("copy_file_range"),
-        RuntimeHelper.POINTER.withName("lseek")
-    ).withName("fuse_operations");
-    static final FunctionDescriptor const$5 = FunctionDescriptor.of(JAVA_INT,
-        RuntimeHelper.POINTER,
-        RuntimeHelper.POINTER,
-        RuntimeHelper.POINTER
-    );
-}
-
-
diff --git a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$15.java b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$15.java
deleted file mode 100644
index 35bb354f..00000000
--- a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$15.java
+++ /dev/null
@@ -1,30 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.linux.amd64.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$15 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$15() {}
-    static final MethodHandle const$0 = RuntimeHelper.upcallHandle(fuse_operations.getattr.class, "apply", constants$14.const$5);
-    static final MethodHandle const$1 = RuntimeHelper.downcallHandle(
-        constants$14.const$5
-    );
-    static final VarHandle const$2 = constants$14.const$4.varHandle(MemoryLayout.PathElement.groupElement("getattr"));
-    static final FunctionDescriptor const$3 = FunctionDescriptor.of(JAVA_INT,
-        RuntimeHelper.POINTER,
-        RuntimeHelper.POINTER,
-        JAVA_LONG
-    );
-    static final MethodHandle const$4 = RuntimeHelper.upcallHandle(fuse_operations.readlink.class, "apply", constants$15.const$3);
-    static final MethodHandle const$5 = RuntimeHelper.downcallHandle(
-        constants$15.const$3
-    );
-}
-
-
diff --git a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$16.java b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$16.java
deleted file mode 100644
index 9a075268..00000000
--- a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$16.java
+++ /dev/null
@@ -1,31 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.linux.amd64.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$16 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$16() {}
-    static final VarHandle const$0 = constants$14.const$4.varHandle(MemoryLayout.PathElement.groupElement("readlink"));
-    static final FunctionDescriptor const$1 = FunctionDescriptor.of(JAVA_INT,
-        RuntimeHelper.POINTER,
-        JAVA_INT,
-        JAVA_LONG
-    );
-    static final MethodHandle const$2 = RuntimeHelper.upcallHandle(fuse_operations.mknod.class, "apply", constants$16.const$1);
-    static final MethodHandle const$3 = RuntimeHelper.downcallHandle(
-        constants$16.const$1
-    );
-    static final VarHandle const$4 = constants$14.const$4.varHandle(MemoryLayout.PathElement.groupElement("mknod"));
-    static final FunctionDescriptor const$5 = FunctionDescriptor.of(JAVA_INT,
-        RuntimeHelper.POINTER,
-        JAVA_INT
-    );
-}
-
-
diff --git a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$17.java b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$17.java
deleted file mode 100644
index a329fbfd..00000000
--- a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$17.java
+++ /dev/null
@@ -1,28 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.linux.amd64.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$17 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$17() {}
-    static final MethodHandle const$0 = RuntimeHelper.upcallHandle(fuse_operations.mkdir.class, "apply", constants$16.const$5);
-    static final MethodHandle const$1 = RuntimeHelper.downcallHandle(
-        constants$16.const$5
-    );
-    static final VarHandle const$2 = constants$14.const$4.varHandle(MemoryLayout.PathElement.groupElement("mkdir"));
-    static final FunctionDescriptor const$3 = FunctionDescriptor.of(JAVA_INT,
-        RuntimeHelper.POINTER
-    );
-    static final MethodHandle const$4 = RuntimeHelper.upcallHandle(fuse_operations.unlink.class, "apply", constants$17.const$3);
-    static final MethodHandle const$5 = RuntimeHelper.downcallHandle(
-        constants$17.const$3
-    );
-}
-
-
diff --git a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$18.java b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$18.java
deleted file mode 100644
index fb3256c3..00000000
--- a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$18.java
+++ /dev/null
@@ -1,27 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.linux.amd64.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$18 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$18() {}
-    static final VarHandle const$0 = constants$14.const$4.varHandle(MemoryLayout.PathElement.groupElement("unlink"));
-    static final MethodHandle const$1 = RuntimeHelper.upcallHandle(fuse_operations.rmdir.class, "apply", constants$17.const$3);
-    static final VarHandle const$2 = constants$14.const$4.varHandle(MemoryLayout.PathElement.groupElement("rmdir"));
-    static final FunctionDescriptor const$3 = FunctionDescriptor.of(JAVA_INT,
-        RuntimeHelper.POINTER,
-        RuntimeHelper.POINTER
-    );
-    static final MethodHandle const$4 = RuntimeHelper.upcallHandle(fuse_operations.symlink.class, "apply", constants$18.const$3);
-    static final MethodHandle const$5 = RuntimeHelper.downcallHandle(
-        constants$18.const$3
-    );
-}
-
-
diff --git a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$19.java b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$19.java
deleted file mode 100644
index 36c7ca8d..00000000
--- a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$19.java
+++ /dev/null
@@ -1,28 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.linux.amd64.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$19 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$19() {}
-    static final VarHandle const$0 = constants$14.const$4.varHandle(MemoryLayout.PathElement.groupElement("symlink"));
-    static final FunctionDescriptor const$1 = FunctionDescriptor.of(JAVA_INT,
-        RuntimeHelper.POINTER,
-        RuntimeHelper.POINTER,
-        JAVA_INT
-    );
-    static final MethodHandle const$2 = RuntimeHelper.upcallHandle(fuse_operations.rename.class, "apply", constants$19.const$1);
-    static final MethodHandle const$3 = RuntimeHelper.downcallHandle(
-        constants$19.const$1
-    );
-    static final VarHandle const$4 = constants$14.const$4.varHandle(MemoryLayout.PathElement.groupElement("rename"));
-    static final MethodHandle const$5 = RuntimeHelper.upcallHandle(fuse_operations.link.class, "apply", constants$18.const$3);
-}
-
-
diff --git a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$2.java b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$2.java
deleted file mode 100644
index 9c25df74..00000000
--- a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$2.java
+++ /dev/null
@@ -1,37 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.linux.amd64.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$2 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$2() {}
-    static final StructLayout const$0 = MemoryLayout.structLayout(
-        JAVA_INT.withName("clone_fd"),
-        JAVA_INT.withName("max_idle_threads")
-    ).withName("fuse_loop_config_v1");
-    static final VarHandle const$1 = constants$2.const$0.varHandle(MemoryLayout.PathElement.groupElement("clone_fd"));
-    static final VarHandle const$2 = constants$2.const$0.varHandle(MemoryLayout.PathElement.groupElement("max_idle_threads"));
-    static final StructLayout const$3 = MemoryLayout.structLayout(
-        JAVA_INT.withName("proto_major"),
-        JAVA_INT.withName("proto_minor"),
-        JAVA_INT.withName("max_write"),
-        JAVA_INT.withName("max_read"),
-        JAVA_INT.withName("max_readahead"),
-        JAVA_INT.withName("capable"),
-        JAVA_INT.withName("want"),
-        JAVA_INT.withName("max_background"),
-        JAVA_INT.withName("congestion_threshold"),
-        JAVA_INT.withName("time_gran"),
-        MemoryLayout.sequenceLayout(22, JAVA_INT).withName("reserved")
-    ).withName("fuse_conn_info");
-    static final VarHandle const$4 = constants$2.const$3.varHandle(MemoryLayout.PathElement.groupElement("proto_major"));
-    static final VarHandle const$5 = constants$2.const$3.varHandle(MemoryLayout.PathElement.groupElement("proto_minor"));
-}
-
-
diff --git a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$20.java b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$20.java
deleted file mode 100644
index c638c8a8..00000000
--- a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$20.java
+++ /dev/null
@@ -1,33 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.linux.amd64.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$20 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$20() {}
-    static final VarHandle const$0 = constants$14.const$4.varHandle(MemoryLayout.PathElement.groupElement("link"));
-    static final FunctionDescriptor const$1 = FunctionDescriptor.of(JAVA_INT,
-        RuntimeHelper.POINTER,
-        JAVA_INT,
-        RuntimeHelper.POINTER
-    );
-    static final MethodHandle const$2 = RuntimeHelper.upcallHandle(fuse_operations.chmod.class, "apply", constants$20.const$1);
-    static final MethodHandle const$3 = RuntimeHelper.downcallHandle(
-        constants$20.const$1
-    );
-    static final VarHandle const$4 = constants$14.const$4.varHandle(MemoryLayout.PathElement.groupElement("chmod"));
-    static final FunctionDescriptor const$5 = FunctionDescriptor.of(JAVA_INT,
-        RuntimeHelper.POINTER,
-        JAVA_INT,
-        JAVA_INT,
-        RuntimeHelper.POINTER
-    );
-}
-
-
diff --git a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$21.java b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$21.java
deleted file mode 100644
index 2b2d719e..00000000
--- a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$21.java
+++ /dev/null
@@ -1,30 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.linux.amd64.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$21 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$21() {}
-    static final MethodHandle const$0 = RuntimeHelper.upcallHandle(fuse_operations.chown.class, "apply", constants$20.const$5);
-    static final MethodHandle const$1 = RuntimeHelper.downcallHandle(
-        constants$20.const$5
-    );
-    static final VarHandle const$2 = constants$14.const$4.varHandle(MemoryLayout.PathElement.groupElement("chown"));
-    static final FunctionDescriptor const$3 = FunctionDescriptor.of(JAVA_INT,
-        RuntimeHelper.POINTER,
-        JAVA_LONG,
-        RuntimeHelper.POINTER
-    );
-    static final MethodHandle const$4 = RuntimeHelper.upcallHandle(fuse_operations.truncate.class, "apply", constants$21.const$3);
-    static final MethodHandle const$5 = RuntimeHelper.downcallHandle(
-        constants$21.const$3
-    );
-}
-
-
diff --git a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$22.java b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$22.java
deleted file mode 100644
index 52466492..00000000
--- a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$22.java
+++ /dev/null
@@ -1,30 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.linux.amd64.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$22 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$22() {}
-    static final VarHandle const$0 = constants$14.const$4.varHandle(MemoryLayout.PathElement.groupElement("truncate"));
-    static final MethodHandle const$1 = RuntimeHelper.upcallHandle(fuse_operations.open.class, "apply", constants$18.const$3);
-    static final VarHandle const$2 = constants$14.const$4.varHandle(MemoryLayout.PathElement.groupElement("open"));
-    static final FunctionDescriptor const$3 = FunctionDescriptor.of(JAVA_INT,
-        RuntimeHelper.POINTER,
-        RuntimeHelper.POINTER,
-        JAVA_LONG,
-        JAVA_LONG,
-        RuntimeHelper.POINTER
-    );
-    static final MethodHandle const$4 = RuntimeHelper.upcallHandle(fuse_operations.read.class, "apply", constants$22.const$3);
-    static final MethodHandle const$5 = RuntimeHelper.downcallHandle(
-        constants$22.const$3
-    );
-}
-
-
diff --git a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$23.java b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$23.java
deleted file mode 100644
index f8d07f1c..00000000
--- a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$23.java
+++ /dev/null
@@ -1,22 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.linux.amd64.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$23 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$23() {}
-    static final VarHandle const$0 = constants$14.const$4.varHandle(MemoryLayout.PathElement.groupElement("read"));
-    static final MethodHandle const$1 = RuntimeHelper.upcallHandle(fuse_operations.write.class, "apply", constants$22.const$3);
-    static final VarHandle const$2 = constants$14.const$4.varHandle(MemoryLayout.PathElement.groupElement("write"));
-    static final MethodHandle const$3 = RuntimeHelper.upcallHandle(fuse_operations.statfs.class, "apply", constants$18.const$3);
-    static final VarHandle const$4 = constants$14.const$4.varHandle(MemoryLayout.PathElement.groupElement("statfs"));
-    static final MethodHandle const$5 = RuntimeHelper.upcallHandle(fuse_operations.flush.class, "apply", constants$18.const$3);
-}
-
-
diff --git a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$24.java b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$24.java
deleted file mode 100644
index 6d43f50c..00000000
--- a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$24.java
+++ /dev/null
@@ -1,22 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.linux.amd64.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$24 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$24() {}
-    static final VarHandle const$0 = constants$14.const$4.varHandle(MemoryLayout.PathElement.groupElement("flush"));
-    static final MethodHandle const$1 = RuntimeHelper.upcallHandle(fuse_operations.release.class, "apply", constants$18.const$3);
-    static final VarHandle const$2 = constants$14.const$4.varHandle(MemoryLayout.PathElement.groupElement("release"));
-    static final MethodHandle const$3 = RuntimeHelper.upcallHandle(fuse_operations.fsync.class, "apply", constants$20.const$1);
-    static final VarHandle const$4 = constants$14.const$4.varHandle(MemoryLayout.PathElement.groupElement("fsync"));
-    static final MethodHandle const$5 = RuntimeHelper.upcallHandle(fuse_operations.setxattr.class, "apply", constants$9.const$5);
-}
-
-
diff --git a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$25.java b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$25.java
deleted file mode 100644
index 85551e6f..00000000
--- a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$25.java
+++ /dev/null
@@ -1,29 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.linux.amd64.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$25 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$25() {}
-    static final VarHandle const$0 = constants$14.const$4.varHandle(MemoryLayout.PathElement.groupElement("setxattr"));
-    static final FunctionDescriptor const$1 = FunctionDescriptor.of(JAVA_INT,
-        RuntimeHelper.POINTER,
-        RuntimeHelper.POINTER,
-        RuntimeHelper.POINTER,
-        JAVA_LONG
-    );
-    static final MethodHandle const$2 = RuntimeHelper.upcallHandle(fuse_operations.getxattr.class, "apply", constants$25.const$1);
-    static final MethodHandle const$3 = RuntimeHelper.downcallHandle(
-        constants$25.const$1
-    );
-    static final VarHandle const$4 = constants$14.const$4.varHandle(MemoryLayout.PathElement.groupElement("getxattr"));
-    static final MethodHandle const$5 = RuntimeHelper.upcallHandle(fuse_operations.listxattr.class, "apply", constants$15.const$3);
-}
-
-
diff --git a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$26.java b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$26.java
deleted file mode 100644
index aea96d63..00000000
--- a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$26.java
+++ /dev/null
@@ -1,29 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.linux.amd64.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$26 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$26() {}
-    static final VarHandle const$0 = constants$14.const$4.varHandle(MemoryLayout.PathElement.groupElement("listxattr"));
-    static final MethodHandle const$1 = RuntimeHelper.upcallHandle(fuse_operations.removexattr.class, "apply", constants$18.const$3);
-    static final VarHandle const$2 = constants$14.const$4.varHandle(MemoryLayout.PathElement.groupElement("removexattr"));
-    static final MethodHandle const$3 = RuntimeHelper.upcallHandle(fuse_operations.opendir.class, "apply", constants$18.const$3);
-    static final VarHandle const$4 = constants$14.const$4.varHandle(MemoryLayout.PathElement.groupElement("opendir"));
-    static final FunctionDescriptor const$5 = FunctionDescriptor.of(JAVA_INT,
-        RuntimeHelper.POINTER,
-        RuntimeHelper.POINTER,
-        RuntimeHelper.POINTER,
-        JAVA_LONG,
-        RuntimeHelper.POINTER,
-        JAVA_INT
-    );
-}
-
-
diff --git a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$27.java b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$27.java
deleted file mode 100644
index ef269e70..00000000
--- a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$27.java
+++ /dev/null
@@ -1,24 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.linux.amd64.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$27 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$27() {}
-    static final MethodHandle const$0 = RuntimeHelper.upcallHandle(fuse_operations.readdir.class, "apply", constants$26.const$5);
-    static final MethodHandle const$1 = RuntimeHelper.downcallHandle(
-        constants$26.const$5
-    );
-    static final VarHandle const$2 = constants$14.const$4.varHandle(MemoryLayout.PathElement.groupElement("readdir"));
-    static final MethodHandle const$3 = RuntimeHelper.upcallHandle(fuse_operations.releasedir.class, "apply", constants$18.const$3);
-    static final VarHandle const$4 = constants$14.const$4.varHandle(MemoryLayout.PathElement.groupElement("releasedir"));
-    static final MethodHandle const$5 = RuntimeHelper.upcallHandle(fuse_operations.fsyncdir.class, "apply", constants$20.const$1);
-}
-
-
diff --git a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$28.java b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$28.java
deleted file mode 100644
index c2ae527c..00000000
--- a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$28.java
+++ /dev/null
@@ -1,27 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.linux.amd64.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$28 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$28() {}
-    static final VarHandle const$0 = constants$14.const$4.varHandle(MemoryLayout.PathElement.groupElement("fsyncdir"));
-    static final FunctionDescriptor const$1 = FunctionDescriptor.of(RuntimeHelper.POINTER,
-        RuntimeHelper.POINTER,
-        RuntimeHelper.POINTER
-    );
-    static final MethodHandle const$2 = RuntimeHelper.upcallHandle(fuse_operations.init.class, "apply", constants$28.const$1);
-    static final MethodHandle const$3 = RuntimeHelper.downcallHandle(
-        constants$28.const$1
-    );
-    static final VarHandle const$4 = constants$14.const$4.varHandle(MemoryLayout.PathElement.groupElement("init"));
-    static final MethodHandle const$5 = RuntimeHelper.upcallHandle(fuse_operations.destroy.class, "apply", constants$5.const$0);
-}
-
-
diff --git a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$29.java b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$29.java
deleted file mode 100644
index b6ca8874..00000000
--- a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$29.java
+++ /dev/null
@@ -1,24 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.linux.amd64.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$29 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$29() {}
-    static final MethodHandle const$0 = RuntimeHelper.downcallHandle(
-        constants$5.const$0
-    );
-    static final VarHandle const$1 = constants$14.const$4.varHandle(MemoryLayout.PathElement.groupElement("destroy"));
-    static final MethodHandle const$2 = RuntimeHelper.upcallHandle(fuse_operations.access.class, "apply", constants$16.const$5);
-    static final VarHandle const$3 = constants$14.const$4.varHandle(MemoryLayout.PathElement.groupElement("access"));
-    static final MethodHandle const$4 = RuntimeHelper.upcallHandle(fuse_operations.create.class, "apply", constants$20.const$1);
-    static final VarHandle const$5 = constants$14.const$4.varHandle(MemoryLayout.PathElement.groupElement("create"));
-}
-
-
diff --git a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$3.java b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$3.java
deleted file mode 100644
index b1084b81..00000000
--- a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$3.java
+++ /dev/null
@@ -1,22 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.linux.amd64.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$3 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$3() {}
-    static final VarHandle const$0 = constants$2.const$3.varHandle(MemoryLayout.PathElement.groupElement("max_write"));
-    static final VarHandle const$1 = constants$2.const$3.varHandle(MemoryLayout.PathElement.groupElement("max_read"));
-    static final VarHandle const$2 = constants$2.const$3.varHandle(MemoryLayout.PathElement.groupElement("max_readahead"));
-    static final VarHandle const$3 = constants$2.const$3.varHandle(MemoryLayout.PathElement.groupElement("capable"));
-    static final VarHandle const$4 = constants$2.const$3.varHandle(MemoryLayout.PathElement.groupElement("want"));
-    static final VarHandle const$5 = constants$2.const$3.varHandle(MemoryLayout.PathElement.groupElement("max_background"));
-}
-
-
diff --git a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$30.java b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$30.java
deleted file mode 100644
index 63022da1..00000000
--- a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$30.java
+++ /dev/null
@@ -1,29 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.linux.amd64.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$30 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$30() {}
-    static final FunctionDescriptor const$0 = FunctionDescriptor.of(JAVA_INT,
-        RuntimeHelper.POINTER,
-        RuntimeHelper.POINTER,
-        JAVA_INT,
-        RuntimeHelper.POINTER
-    );
-    static final MethodHandle const$1 = RuntimeHelper.upcallHandle(fuse_operations.lock.class, "apply", constants$30.const$0);
-    static final MethodHandle const$2 = RuntimeHelper.downcallHandle(
-        constants$30.const$0
-    );
-    static final VarHandle const$3 = constants$14.const$4.varHandle(MemoryLayout.PathElement.groupElement("lock"));
-    static final MethodHandle const$4 = RuntimeHelper.upcallHandle(fuse_operations.utimens.class, "apply", constants$14.const$5);
-    static final VarHandle const$5 = constants$14.const$4.varHandle(MemoryLayout.PathElement.groupElement("utimens"));
-}
-
-
diff --git a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$31.java b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$31.java
deleted file mode 100644
index d79dd51d..00000000
--- a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$31.java
+++ /dev/null
@@ -1,31 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.linux.amd64.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$31 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$31() {}
-    static final MethodHandle const$0 = RuntimeHelper.upcallHandle(fuse_operations.bmap.class, "apply", constants$21.const$3);
-    static final VarHandle const$1 = constants$14.const$4.varHandle(MemoryLayout.PathElement.groupElement("bmap"));
-    static final FunctionDescriptor const$2 = FunctionDescriptor.of(JAVA_INT,
-        RuntimeHelper.POINTER,
-        JAVA_INT,
-        RuntimeHelper.POINTER,
-        RuntimeHelper.POINTER,
-        JAVA_INT,
-        RuntimeHelper.POINTER
-    );
-    static final MethodHandle const$3 = RuntimeHelper.upcallHandle(fuse_operations.ioctl.class, "apply", constants$31.const$2);
-    static final MethodHandle const$4 = RuntimeHelper.downcallHandle(
-        constants$31.const$2
-    );
-    static final VarHandle const$5 = constants$14.const$4.varHandle(MemoryLayout.PathElement.groupElement("ioctl"));
-}
-
-
diff --git a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$32.java b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$32.java
deleted file mode 100644
index 4a3430b9..00000000
--- a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$32.java
+++ /dev/null
@@ -1,34 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.linux.amd64.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$32 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$32() {}
-    static final FunctionDescriptor const$0 = FunctionDescriptor.of(JAVA_INT,
-        RuntimeHelper.POINTER,
-        RuntimeHelper.POINTER,
-        RuntimeHelper.POINTER,
-        RuntimeHelper.POINTER
-    );
-    static final MethodHandle const$1 = RuntimeHelper.upcallHandle(fuse_operations.poll.class, "apply", constants$32.const$0);
-    static final MethodHandle const$2 = RuntimeHelper.downcallHandle(
-        constants$32.const$0
-    );
-    static final VarHandle const$3 = constants$14.const$4.varHandle(MemoryLayout.PathElement.groupElement("poll"));
-    static final FunctionDescriptor const$4 = FunctionDescriptor.of(JAVA_INT,
-        RuntimeHelper.POINTER,
-        RuntimeHelper.POINTER,
-        JAVA_LONG,
-        RuntimeHelper.POINTER
-    );
-    static final MethodHandle const$5 = RuntimeHelper.upcallHandle(fuse_operations.write_buf.class, "apply", constants$32.const$4);
-}
-
-
diff --git a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$33.java b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$33.java
deleted file mode 100644
index 6d0ed668..00000000
--- a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$33.java
+++ /dev/null
@@ -1,24 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.linux.amd64.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$33 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$33() {}
-    static final MethodHandle const$0 = RuntimeHelper.downcallHandle(
-        constants$32.const$4
-    );
-    static final VarHandle const$1 = constants$14.const$4.varHandle(MemoryLayout.PathElement.groupElement("write_buf"));
-    static final MethodHandle const$2 = RuntimeHelper.upcallHandle(fuse_operations.read_buf.class, "apply", constants$22.const$3);
-    static final VarHandle const$3 = constants$14.const$4.varHandle(MemoryLayout.PathElement.groupElement("read_buf"));
-    static final MethodHandle const$4 = RuntimeHelper.upcallHandle(fuse_operations.flock.class, "apply", constants$19.const$1);
-    static final VarHandle const$5 = constants$14.const$4.varHandle(MemoryLayout.PathElement.groupElement("flock"));
-}
-
-
diff --git a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$34.java b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$34.java
deleted file mode 100644
index e1028ee9..00000000
--- a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$34.java
+++ /dev/null
@@ -1,39 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.linux.amd64.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$34 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$34() {}
-    static final FunctionDescriptor const$0 = FunctionDescriptor.of(JAVA_INT,
-        RuntimeHelper.POINTER,
-        JAVA_INT,
-        JAVA_LONG,
-        JAVA_LONG,
-        RuntimeHelper.POINTER
-    );
-    static final MethodHandle const$1 = RuntimeHelper.upcallHandle(fuse_operations.fallocate.class, "apply", constants$34.const$0);
-    static final MethodHandle const$2 = RuntimeHelper.downcallHandle(
-        constants$34.const$0
-    );
-    static final VarHandle const$3 = constants$14.const$4.varHandle(MemoryLayout.PathElement.groupElement("fallocate"));
-    static final FunctionDescriptor const$4 = FunctionDescriptor.of(JAVA_LONG,
-        RuntimeHelper.POINTER,
-        RuntimeHelper.POINTER,
-        JAVA_LONG,
-        RuntimeHelper.POINTER,
-        RuntimeHelper.POINTER,
-        JAVA_LONG,
-        JAVA_LONG,
-        JAVA_INT
-    );
-    static final MethodHandle const$5 = RuntimeHelper.upcallHandle(fuse_operations.copy_file_range.class, "apply", constants$34.const$4);
-}
-
-
diff --git a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$35.java b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$35.java
deleted file mode 100644
index 83f7d046..00000000
--- a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$35.java
+++ /dev/null
@@ -1,31 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.linux.amd64.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$35 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$35() {}
-    static final MethodHandle const$0 = RuntimeHelper.downcallHandle(
-        constants$34.const$4
-    );
-    static final VarHandle const$1 = constants$14.const$4.varHandle(MemoryLayout.PathElement.groupElement("copy_file_range"));
-    static final FunctionDescriptor const$2 = FunctionDescriptor.of(JAVA_LONG,
-        RuntimeHelper.POINTER,
-        JAVA_LONG,
-        JAVA_INT,
-        RuntimeHelper.POINTER
-    );
-    static final MethodHandle const$3 = RuntimeHelper.upcallHandle(fuse_operations.lseek.class, "apply", constants$35.const$2);
-    static final MethodHandle const$4 = RuntimeHelper.downcallHandle(
-        constants$35.const$2
-    );
-    static final VarHandle const$5 = constants$14.const$4.varHandle(MemoryLayout.PathElement.groupElement("lseek"));
-}
-
-
diff --git a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$36.java b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$36.java
deleted file mode 100644
index 01ef8642..00000000
--- a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$36.java
+++ /dev/null
@@ -1,42 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.linux.amd64.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$36 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$36() {}
-    static final MethodHandle const$0 = RuntimeHelper.downcallHandle(
-        "fuse_lib_help",
-        constants$5.const$0
-    );
-    static final FunctionDescriptor const$1 = FunctionDescriptor.of(RuntimeHelper.POINTER,
-        RuntimeHelper.POINTER,
-        RuntimeHelper.POINTER,
-        JAVA_LONG,
-        RuntimeHelper.POINTER
-    );
-    static final MethodHandle const$2 = RuntimeHelper.downcallHandle(
-        "fuse_new",
-        constants$36.const$1
-    );
-    static final MethodHandle const$3 = RuntimeHelper.downcallHandle(
-        "fuse_mount",
-        constants$18.const$3
-    );
-    static final MethodHandle const$4 = RuntimeHelper.downcallHandle(
-        "fuse_unmount",
-        constants$5.const$0
-    );
-    static final MethodHandle const$5 = RuntimeHelper.downcallHandle(
-        "fuse_destroy",
-        constants$5.const$0
-    );
-}
-
-
diff --git a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$37.java b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$37.java
deleted file mode 100644
index c99ef5f0..00000000
--- a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$37.java
+++ /dev/null
@@ -1,35 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.linux.amd64.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$37 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$37() {}
-    static final MethodHandle const$0 = RuntimeHelper.downcallHandle(
-        "fuse_loop",
-        constants$17.const$3
-    );
-    static final MethodHandle const$1 = RuntimeHelper.downcallHandle(
-        "fuse_exit",
-        constants$5.const$0
-    );
-    static final MethodHandle const$2 = RuntimeHelper.downcallHandle(
-        "fuse_loop_mt",
-        constants$18.const$3
-    );
-    static final FunctionDescriptor const$3 = FunctionDescriptor.of(RuntimeHelper.POINTER,
-        RuntimeHelper.POINTER
-    );
-    static final MethodHandle const$4 = RuntimeHelper.downcallHandle(
-        "fuse_get_session",
-        constants$37.const$3
-    );
-}
-
-
diff --git a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$4.java b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$4.java
deleted file mode 100644
index aa08fb26..00000000
--- a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$4.java
+++ /dev/null
@@ -1,28 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.linux.amd64.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$4 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$4() {}
-    static final VarHandle const$0 = constants$2.const$3.varHandle(MemoryLayout.PathElement.groupElement("congestion_threshold"));
-    static final VarHandle const$1 = constants$2.const$3.varHandle(MemoryLayout.PathElement.groupElement("time_gran"));
-    static final FunctionDescriptor const$2 = FunctionDescriptor.of(JAVA_INT);
-    static final MethodHandle const$3 = RuntimeHelper.downcallHandle(
-        "fuse_version",
-        constants$4.const$2
-    );
-    static final FunctionDescriptor const$4 = FunctionDescriptor.of(RuntimeHelper.POINTER);
-    static final MethodHandle const$5 = RuntimeHelper.downcallHandle(
-        "fuse_loop_cfg_create",
-        constants$4.const$4
-    );
-}
-
-
diff --git a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$5.java b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$5.java
deleted file mode 100644
index bef6a785..00000000
--- a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$5.java
+++ /dev/null
@@ -1,61 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.linux.amd64.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$5 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$5() {}
-    static final FunctionDescriptor const$0 = FunctionDescriptor.ofVoid(
-        RuntimeHelper.POINTER
-    );
-    static final MethodHandle const$1 = RuntimeHelper.downcallHandle(
-        "fuse_loop_cfg_destroy",
-        constants$5.const$0
-    );
-    static final FunctionDescriptor const$2 = FunctionDescriptor.ofVoid(
-        RuntimeHelper.POINTER,
-        JAVA_INT
-    );
-    static final MethodHandle const$3 = RuntimeHelper.downcallHandle(
-        "fuse_loop_cfg_set_max_threads",
-        constants$5.const$2
-    );
-    static final MethodHandle const$4 = RuntimeHelper.downcallHandle(
-        "fuse_loop_cfg_set_clone_fd",
-        constants$5.const$2
-    );
-    static final StructLayout const$5 = MemoryLayout.structLayout(
-        JAVA_LONG.withName("st_dev"),
-        JAVA_LONG.withName("st_ino"),
-        JAVA_LONG.withName("st_nlink"),
-        JAVA_INT.withName("st_mode"),
-        JAVA_INT.withName("st_uid"),
-        JAVA_INT.withName("st_gid"),
-        JAVA_INT.withName("__pad0"),
-        JAVA_LONG.withName("st_rdev"),
-        JAVA_LONG.withName("st_size"),
-        JAVA_LONG.withName("st_blksize"),
-        JAVA_LONG.withName("st_blocks"),
-        MemoryLayout.structLayout(
-            JAVA_LONG.withName("tv_sec"),
-            JAVA_LONG.withName("tv_nsec")
-        ).withName("st_atim"),
-        MemoryLayout.structLayout(
-            JAVA_LONG.withName("tv_sec"),
-            JAVA_LONG.withName("tv_nsec")
-        ).withName("st_mtim"),
-        MemoryLayout.structLayout(
-            JAVA_LONG.withName("tv_sec"),
-            JAVA_LONG.withName("tv_nsec")
-        ).withName("st_ctim"),
-        MemoryLayout.sequenceLayout(3, JAVA_LONG).withName("__glibc_reserved")
-    ).withName("stat");
-}
-
-
diff --git a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$6.java b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$6.java
deleted file mode 100644
index 3411c098..00000000
--- a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$6.java
+++ /dev/null
@@ -1,22 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.linux.amd64.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$6 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$6() {}
-    static final VarHandle const$0 = constants$5.const$5.varHandle(MemoryLayout.PathElement.groupElement("st_dev"));
-    static final VarHandle const$1 = constants$5.const$5.varHandle(MemoryLayout.PathElement.groupElement("st_ino"));
-    static final VarHandle const$2 = constants$5.const$5.varHandle(MemoryLayout.PathElement.groupElement("st_nlink"));
-    static final VarHandle const$3 = constants$5.const$5.varHandle(MemoryLayout.PathElement.groupElement("st_mode"));
-    static final VarHandle const$4 = constants$5.const$5.varHandle(MemoryLayout.PathElement.groupElement("st_uid"));
-    static final VarHandle const$5 = constants$5.const$5.varHandle(MemoryLayout.PathElement.groupElement("st_gid"));
-}
-
-
diff --git a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$7.java b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$7.java
deleted file mode 100644
index 7d827211..00000000
--- a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$7.java
+++ /dev/null
@@ -1,35 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.linux.amd64.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$7 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$7() {}
-    static final VarHandle const$0 = constants$5.const$5.varHandle(MemoryLayout.PathElement.groupElement("__pad0"));
-    static final VarHandle const$1 = constants$5.const$5.varHandle(MemoryLayout.PathElement.groupElement("st_rdev"));
-    static final VarHandle const$2 = constants$5.const$5.varHandle(MemoryLayout.PathElement.groupElement("st_size"));
-    static final VarHandle const$3 = constants$5.const$5.varHandle(MemoryLayout.PathElement.groupElement("st_blksize"));
-    static final VarHandle const$4 = constants$5.const$5.varHandle(MemoryLayout.PathElement.groupElement("st_blocks"));
-    static final StructLayout const$5 = MemoryLayout.structLayout(
-        JAVA_LONG.withName("f_bsize"),
-        JAVA_LONG.withName("f_frsize"),
-        JAVA_LONG.withName("f_blocks"),
-        JAVA_LONG.withName("f_bfree"),
-        JAVA_LONG.withName("f_bavail"),
-        JAVA_LONG.withName("f_files"),
-        JAVA_LONG.withName("f_ffree"),
-        JAVA_LONG.withName("f_favail"),
-        JAVA_LONG.withName("f_fsid"),
-        JAVA_LONG.withName("f_flag"),
-        JAVA_LONG.withName("f_namemax"),
-        MemoryLayout.sequenceLayout(6, JAVA_INT).withName("__f_spare")
-    ).withName("statvfs");
-}
-
-
diff --git a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$8.java b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$8.java
deleted file mode 100644
index e6ba9c20..00000000
--- a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$8.java
+++ /dev/null
@@ -1,22 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.linux.amd64.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$8 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$8() {}
-    static final VarHandle const$0 = constants$7.const$5.varHandle(MemoryLayout.PathElement.groupElement("f_bsize"));
-    static final VarHandle const$1 = constants$7.const$5.varHandle(MemoryLayout.PathElement.groupElement("f_frsize"));
-    static final VarHandle const$2 = constants$7.const$5.varHandle(MemoryLayout.PathElement.groupElement("f_blocks"));
-    static final VarHandle const$3 = constants$7.const$5.varHandle(MemoryLayout.PathElement.groupElement("f_bfree"));
-    static final VarHandle const$4 = constants$7.const$5.varHandle(MemoryLayout.PathElement.groupElement("f_bavail"));
-    static final VarHandle const$5 = constants$7.const$5.varHandle(MemoryLayout.PathElement.groupElement("f_files"));
-}
-
-
diff --git a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$9.java b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$9.java
deleted file mode 100644
index 7214ca38..00000000
--- a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/constants$9.java
+++ /dev/null
@@ -1,28 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.linux.amd64.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$9 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$9() {}
-    static final VarHandle const$0 = constants$7.const$5.varHandle(MemoryLayout.PathElement.groupElement("f_ffree"));
-    static final VarHandle const$1 = constants$7.const$5.varHandle(MemoryLayout.PathElement.groupElement("f_favail"));
-    static final VarHandle const$2 = constants$7.const$5.varHandle(MemoryLayout.PathElement.groupElement("f_fsid"));
-    static final VarHandle const$3 = constants$7.const$5.varHandle(MemoryLayout.PathElement.groupElement("f_flag"));
-    static final VarHandle const$4 = constants$7.const$5.varHandle(MemoryLayout.PathElement.groupElement("f_namemax"));
-    static final FunctionDescriptor const$5 = FunctionDescriptor.of(JAVA_INT,
-        RuntimeHelper.POINTER,
-        RuntimeHelper.POINTER,
-        RuntimeHelper.POINTER,
-        JAVA_LONG,
-        JAVA_INT
-    );
-}
-
-
diff --git a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/fuse_args.java b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/fuse_args.java
index 7f32d0dd..339b1d5f 100644
--- a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/fuse_args.java
+++ b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/fuse_args.java
@@ -2,112 +2,220 @@
 
 package org.cryptomator.jfuse.linux.amd64.extr.fuse3;
 
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
+import java.lang.invoke.*;
 import java.lang.foreign.*;
+import java.nio.ByteOrder;
+import java.util.*;
+import java.util.function.*;
+import java.util.stream.*;
+
 import static java.lang.foreign.ValueLayout.*;
+import static java.lang.foreign.MemoryLayout.PathElement.*;
+
 /**
- * {@snippet :
+ * {@snippet lang=c :
  * struct fuse_args {
  *     int argc;
- *     char** argv;
+ *     char **argv;
  *     int allocated;
- * };
+ * }
  * }
  */
 public class fuse_args {
 
-    public static MemoryLayout $LAYOUT() {
-        return constants$0.const$0;
+    fuse_args() {
+        // Should not be called directly
+    }
+
+    private static final GroupLayout $LAYOUT = MemoryLayout.structLayout(
+        fuse_h.C_INT.withName("argc"),
+        MemoryLayout.paddingLayout(4),
+        fuse_h.C_POINTER.withName("argv"),
+        fuse_h.C_INT.withName("allocated"),
+        MemoryLayout.paddingLayout(4)
+    ).withName("fuse_args");
+
+    /**
+     * The layout of this struct
+     */
+    public static final GroupLayout layout() {
+        return $LAYOUT;
     }
-    public static VarHandle argc$VH() {
-        return constants$0.const$1;
+
+    private static final OfInt argc$LAYOUT = (OfInt)$LAYOUT.select(groupElement("argc"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int argc
+     * }
+     */
+    public static final OfInt argc$layout() {
+        return argc$LAYOUT;
     }
+
+    private static final long argc$OFFSET = 0;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int argc
+     * }
+     */
+    public static final long argc$offset() {
+        return argc$OFFSET;
+    }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int argc;
+     * {@snippet lang=c :
+     * int argc
      * }
      */
-    public static int argc$get(MemorySegment seg) {
-        return (int)constants$0.const$1.get(seg);
+    public static int argc(MemorySegment struct) {
+        return struct.get(argc$LAYOUT, argc$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int argc;
+     * {@snippet lang=c :
+     * int argc
      * }
      */
-    public static void argc$set(MemorySegment seg, int x) {
-        constants$0.const$1.set(seg, x);
+    public static void argc(MemorySegment struct, int fieldValue) {
+        struct.set(argc$LAYOUT, argc$OFFSET, fieldValue);
     }
-    public static int argc$get(MemorySegment seg, long index) {
-        return (int)constants$0.const$1.get(seg.asSlice(index*sizeof()));
-    }
-    public static void argc$set(MemorySegment seg, long index, int x) {
-        constants$0.const$1.set(seg.asSlice(index*sizeof()), x);
+
+    private static final AddressLayout argv$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("argv"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * char **argv
+     * }
+     */
+    public static final AddressLayout argv$layout() {
+        return argv$LAYOUT;
     }
-    public static VarHandle argv$VH() {
-        return constants$0.const$2;
+
+    private static final long argv$OFFSET = 8;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * char **argv
+     * }
+     */
+    public static final long argv$offset() {
+        return argv$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * char** argv;
+     * {@snippet lang=c :
+     * char **argv
      * }
      */
-    public static MemorySegment argv$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$0.const$2.get(seg);
+    public static MemorySegment argv(MemorySegment struct) {
+        return struct.get(argv$LAYOUT, argv$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * char** argv;
+     * {@snippet lang=c :
+     * char **argv
      * }
      */
-    public static void argv$set(MemorySegment seg, MemorySegment x) {
-        constants$0.const$2.set(seg, x);
-    }
-    public static MemorySegment argv$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$0.const$2.get(seg.asSlice(index*sizeof()));
+    public static void argv(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(argv$LAYOUT, argv$OFFSET, fieldValue);
     }
-    public static void argv$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$0.const$2.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt allocated$LAYOUT = (OfInt)$LAYOUT.select(groupElement("allocated"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int allocated
+     * }
+     */
+    public static final OfInt allocated$layout() {
+        return allocated$LAYOUT;
     }
-    public static VarHandle allocated$VH() {
-        return constants$0.const$3;
+
+    private static final long allocated$OFFSET = 16;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int allocated
+     * }
+     */
+    public static final long allocated$offset() {
+        return allocated$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int allocated;
+     * {@snippet lang=c :
+     * int allocated
      * }
      */
-    public static int allocated$get(MemorySegment seg) {
-        return (int)constants$0.const$3.get(seg);
+    public static int allocated(MemorySegment struct) {
+        return struct.get(allocated$LAYOUT, allocated$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int allocated;
+     * {@snippet lang=c :
+     * int allocated
      * }
      */
-    public static void allocated$set(MemorySegment seg, int x) {
-        constants$0.const$3.set(seg, x);
+    public static void allocated(MemorySegment struct, int fieldValue) {
+        struct.set(allocated$LAYOUT, allocated$OFFSET, fieldValue);
     }
-    public static int allocated$get(MemorySegment seg, long index) {
-        return (int)constants$0.const$3.get(seg.asSlice(index*sizeof()));
+
+    /**
+     * Obtains a slice of {@code arrayParam} which selects the array element at {@code index}.
+     * The returned segment has address {@code arrayParam.address() + index * layout().byteSize()}
+     */
+    public static MemorySegment asSlice(MemorySegment array, long index) {
+        return array.asSlice(layout().byteSize() * index);
     }
-    public static void allocated$set(MemorySegment seg, long index, int x) {
-        constants$0.const$3.set(seg.asSlice(index*sizeof()), x);
+
+    /**
+     * The size (in bytes) of this struct
+     */
+    public static long sizeof() { return layout().byteSize(); }
+
+    /**
+     * Allocate a segment of size {@code layout().byteSize()} using {@code allocator}
+     */
+    public static MemorySegment allocate(SegmentAllocator allocator) {
+        return allocator.allocate(layout());
     }
-    public static long sizeof() { return $LAYOUT().byteSize(); }
-    public static MemorySegment allocate(SegmentAllocator allocator) { return allocator.allocate($LAYOUT()); }
-    public static MemorySegment allocateArray(long len, SegmentAllocator allocator) {
-        return allocator.allocate(MemoryLayout.sequenceLayout(len, $LAYOUT()));
+
+    /**
+     * Allocate an array of size {@code elementCount} using {@code allocator}.
+     * The returned segment has size {@code elementCount * layout().byteSize()}.
+     */
+    public static MemorySegment allocateArray(long elementCount, SegmentAllocator allocator) {
+        return allocator.allocate(MemoryLayout.sequenceLayout(elementCount, layout()));
     }
-    public static MemorySegment ofAddress(MemorySegment addr, Arena scope) { return RuntimeHelper.asArray(addr, $LAYOUT(), 1, scope); }
-}
 
+    /**
+     * Reinterprets {@code addr} using target {@code arena} and {@code cleanupAction) (if any).
+     * The returned segment has size {@code layout().byteSize()}
+     */
+    public static MemorySegment reinterpret(MemorySegment addr, Arena arena, Consumer<MemorySegment> cleanup) {
+        return reinterpret(addr, 1, arena, cleanup);
+    }
+
+    /**
+     * Reinterprets {@code addr} using target {@code arena} and {@code cleanupAction) (if any).
+     * The returned segment has size {@code elementCount * layout().byteSize()}
+     */
+    public static MemorySegment reinterpret(MemorySegment addr, long elementCount, Arena arena, Consumer<MemorySegment> cleanup) {
+        return addr.reinterpret(layout().byteSize() * elementCount, arena, cleanup);
+    }
+}
 
diff --git a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/fuse_config.java b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/fuse_config.java
index 24565554..ffc9d7de 100644
--- a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/fuse_config.java
+++ b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/fuse_config.java
@@ -2,13 +2,18 @@
 
 package org.cryptomator.jfuse.linux.amd64.extr.fuse3;
 
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
+import java.lang.invoke.*;
 import java.lang.foreign.*;
+import java.nio.ByteOrder;
+import java.util.*;
+import java.util.function.*;
+import java.util.stream.*;
+
 import static java.lang.foreign.ValueLayout.*;
+import static java.lang.foreign.MemoryLayout.PathElement.*;
+
 /**
- * {@snippet :
+ * {@snippet lang=c :
  * struct fuse_config {
  *     int set_gid;
  *     unsigned int gid;
@@ -33,697 +38,1196 @@
  *     double ac_attr_timeout;
  *     int nullpath_ok;
  *     int show_help;
- *     char* modules;
+ *     char *modules;
  *     int debug;
- * };
+ * }
  * }
  */
 public class fuse_config {
 
-    public static MemoryLayout $LAYOUT() {
-        return constants$10.const$2;
+    fuse_config() {
+        // Should not be called directly
     }
-    public static VarHandle set_gid$VH() {
-        return constants$10.const$3;
+
+    private static final GroupLayout $LAYOUT = MemoryLayout.structLayout(
+        fuse_h.C_INT.withName("set_gid"),
+        fuse_h.C_INT.withName("gid"),
+        fuse_h.C_INT.withName("set_uid"),
+        fuse_h.C_INT.withName("uid"),
+        fuse_h.C_INT.withName("set_mode"),
+        fuse_h.C_INT.withName("umask"),
+        fuse_h.C_DOUBLE.withName("entry_timeout"),
+        fuse_h.C_DOUBLE.withName("negative_timeout"),
+        fuse_h.C_DOUBLE.withName("attr_timeout"),
+        fuse_h.C_INT.withName("intr"),
+        fuse_h.C_INT.withName("intr_signal"),
+        fuse_h.C_INT.withName("remember"),
+        fuse_h.C_INT.withName("hard_remove"),
+        fuse_h.C_INT.withName("use_ino"),
+        fuse_h.C_INT.withName("readdir_ino"),
+        fuse_h.C_INT.withName("direct_io"),
+        fuse_h.C_INT.withName("kernel_cache"),
+        fuse_h.C_INT.withName("auto_cache"),
+        fuse_h.C_INT.withName("no_rofd_flush"),
+        fuse_h.C_INT.withName("ac_attr_timeout_set"),
+        MemoryLayout.paddingLayout(4),
+        fuse_h.C_DOUBLE.withName("ac_attr_timeout"),
+        fuse_h.C_INT.withName("nullpath_ok"),
+        fuse_h.C_INT.withName("show_help"),
+        fuse_h.C_POINTER.withName("modules"),
+        fuse_h.C_INT.withName("debug"),
+        MemoryLayout.paddingLayout(4)
+    ).withName("fuse_config");
+
+    /**
+     * The layout of this struct
+     */
+    public static final GroupLayout layout() {
+        return $LAYOUT;
     }
+
+    private static final OfInt set_gid$LAYOUT = (OfInt)$LAYOUT.select(groupElement("set_gid"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int set_gid
+     * }
+     */
+    public static final OfInt set_gid$layout() {
+        return set_gid$LAYOUT;
+    }
+
+    private static final long set_gid$OFFSET = 0;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int set_gid
+     * }
+     */
+    public static final long set_gid$offset() {
+        return set_gid$OFFSET;
+    }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int set_gid;
+     * {@snippet lang=c :
+     * int set_gid
      * }
      */
-    public static int set_gid$get(MemorySegment seg) {
-        return (int)constants$10.const$3.get(seg);
+    public static int set_gid(MemorySegment struct) {
+        return struct.get(set_gid$LAYOUT, set_gid$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int set_gid;
+     * {@snippet lang=c :
+     * int set_gid
      * }
      */
-    public static void set_gid$set(MemorySegment seg, int x) {
-        constants$10.const$3.set(seg, x);
+    public static void set_gid(MemorySegment struct, int fieldValue) {
+        struct.set(set_gid$LAYOUT, set_gid$OFFSET, fieldValue);
     }
-    public static int set_gid$get(MemorySegment seg, long index) {
-        return (int)constants$10.const$3.get(seg.asSlice(index*sizeof()));
-    }
-    public static void set_gid$set(MemorySegment seg, long index, int x) {
-        constants$10.const$3.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt gid$LAYOUT = (OfInt)$LAYOUT.select(groupElement("gid"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * unsigned int gid
+     * }
+     */
+    public static final OfInt gid$layout() {
+        return gid$LAYOUT;
     }
-    public static VarHandle gid$VH() {
-        return constants$10.const$4;
+
+    private static final long gid$OFFSET = 4;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * unsigned int gid
+     * }
+     */
+    public static final long gid$offset() {
+        return gid$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned int gid;
+     * {@snippet lang=c :
+     * unsigned int gid
      * }
      */
-    public static int gid$get(MemorySegment seg) {
-        return (int)constants$10.const$4.get(seg);
+    public static int gid(MemorySegment struct) {
+        return struct.get(gid$LAYOUT, gid$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned int gid;
+     * {@snippet lang=c :
+     * unsigned int gid
      * }
      */
-    public static void gid$set(MemorySegment seg, int x) {
-        constants$10.const$4.set(seg, x);
-    }
-    public static int gid$get(MemorySegment seg, long index) {
-        return (int)constants$10.const$4.get(seg.asSlice(index*sizeof()));
+    public static void gid(MemorySegment struct, int fieldValue) {
+        struct.set(gid$LAYOUT, gid$OFFSET, fieldValue);
     }
-    public static void gid$set(MemorySegment seg, long index, int x) {
-        constants$10.const$4.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt set_uid$LAYOUT = (OfInt)$LAYOUT.select(groupElement("set_uid"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int set_uid
+     * }
+     */
+    public static final OfInt set_uid$layout() {
+        return set_uid$LAYOUT;
     }
-    public static VarHandle set_uid$VH() {
-        return constants$10.const$5;
+
+    private static final long set_uid$OFFSET = 8;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int set_uid
+     * }
+     */
+    public static final long set_uid$offset() {
+        return set_uid$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int set_uid;
+     * {@snippet lang=c :
+     * int set_uid
      * }
      */
-    public static int set_uid$get(MemorySegment seg) {
-        return (int)constants$10.const$5.get(seg);
+    public static int set_uid(MemorySegment struct) {
+        return struct.get(set_uid$LAYOUT, set_uid$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int set_uid;
+     * {@snippet lang=c :
+     * int set_uid
      * }
      */
-    public static void set_uid$set(MemorySegment seg, int x) {
-        constants$10.const$5.set(seg, x);
-    }
-    public static int set_uid$get(MemorySegment seg, long index) {
-        return (int)constants$10.const$5.get(seg.asSlice(index*sizeof()));
+    public static void set_uid(MemorySegment struct, int fieldValue) {
+        struct.set(set_uid$LAYOUT, set_uid$OFFSET, fieldValue);
     }
-    public static void set_uid$set(MemorySegment seg, long index, int x) {
-        constants$10.const$5.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt uid$LAYOUT = (OfInt)$LAYOUT.select(groupElement("uid"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * unsigned int uid
+     * }
+     */
+    public static final OfInt uid$layout() {
+        return uid$LAYOUT;
     }
-    public static VarHandle uid$VH() {
-        return constants$11.const$0;
+
+    private static final long uid$OFFSET = 12;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * unsigned int uid
+     * }
+     */
+    public static final long uid$offset() {
+        return uid$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned int uid;
+     * {@snippet lang=c :
+     * unsigned int uid
      * }
      */
-    public static int uid$get(MemorySegment seg) {
-        return (int)constants$11.const$0.get(seg);
+    public static int uid(MemorySegment struct) {
+        return struct.get(uid$LAYOUT, uid$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned int uid;
+     * {@snippet lang=c :
+     * unsigned int uid
      * }
      */
-    public static void uid$set(MemorySegment seg, int x) {
-        constants$11.const$0.set(seg, x);
+    public static void uid(MemorySegment struct, int fieldValue) {
+        struct.set(uid$LAYOUT, uid$OFFSET, fieldValue);
     }
-    public static int uid$get(MemorySegment seg, long index) {
-        return (int)constants$11.const$0.get(seg.asSlice(index*sizeof()));
-    }
-    public static void uid$set(MemorySegment seg, long index, int x) {
-        constants$11.const$0.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt set_mode$LAYOUT = (OfInt)$LAYOUT.select(groupElement("set_mode"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int set_mode
+     * }
+     */
+    public static final OfInt set_mode$layout() {
+        return set_mode$LAYOUT;
     }
-    public static VarHandle set_mode$VH() {
-        return constants$11.const$1;
+
+    private static final long set_mode$OFFSET = 16;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int set_mode
+     * }
+     */
+    public static final long set_mode$offset() {
+        return set_mode$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int set_mode;
+     * {@snippet lang=c :
+     * int set_mode
      * }
      */
-    public static int set_mode$get(MemorySegment seg) {
-        return (int)constants$11.const$1.get(seg);
+    public static int set_mode(MemorySegment struct) {
+        return struct.get(set_mode$LAYOUT, set_mode$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int set_mode;
+     * {@snippet lang=c :
+     * int set_mode
      * }
      */
-    public static void set_mode$set(MemorySegment seg, int x) {
-        constants$11.const$1.set(seg, x);
-    }
-    public static int set_mode$get(MemorySegment seg, long index) {
-        return (int)constants$11.const$1.get(seg.asSlice(index*sizeof()));
+    public static void set_mode(MemorySegment struct, int fieldValue) {
+        struct.set(set_mode$LAYOUT, set_mode$OFFSET, fieldValue);
     }
-    public static void set_mode$set(MemorySegment seg, long index, int x) {
-        constants$11.const$1.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt umask$LAYOUT = (OfInt)$LAYOUT.select(groupElement("umask"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * unsigned int umask
+     * }
+     */
+    public static final OfInt umask$layout() {
+        return umask$LAYOUT;
     }
-    public static VarHandle umask$VH() {
-        return constants$11.const$2;
+
+    private static final long umask$OFFSET = 20;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * unsigned int umask
+     * }
+     */
+    public static final long umask$offset() {
+        return umask$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned int umask;
+     * {@snippet lang=c :
+     * unsigned int umask
      * }
      */
-    public static int umask$get(MemorySegment seg) {
-        return (int)constants$11.const$2.get(seg);
+    public static int umask(MemorySegment struct) {
+        return struct.get(umask$LAYOUT, umask$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned int umask;
+     * {@snippet lang=c :
+     * unsigned int umask
      * }
      */
-    public static void umask$set(MemorySegment seg, int x) {
-        constants$11.const$2.set(seg, x);
-    }
-    public static int umask$get(MemorySegment seg, long index) {
-        return (int)constants$11.const$2.get(seg.asSlice(index*sizeof()));
+    public static void umask(MemorySegment struct, int fieldValue) {
+        struct.set(umask$LAYOUT, umask$OFFSET, fieldValue);
     }
-    public static void umask$set(MemorySegment seg, long index, int x) {
-        constants$11.const$2.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfDouble entry_timeout$LAYOUT = (OfDouble)$LAYOUT.select(groupElement("entry_timeout"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * double entry_timeout
+     * }
+     */
+    public static final OfDouble entry_timeout$layout() {
+        return entry_timeout$LAYOUT;
     }
-    public static VarHandle entry_timeout$VH() {
-        return constants$11.const$3;
+
+    private static final long entry_timeout$OFFSET = 24;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * double entry_timeout
+     * }
+     */
+    public static final long entry_timeout$offset() {
+        return entry_timeout$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * double entry_timeout;
+     * {@snippet lang=c :
+     * double entry_timeout
      * }
      */
-    public static double entry_timeout$get(MemorySegment seg) {
-        return (double)constants$11.const$3.get(seg);
+    public static double entry_timeout(MemorySegment struct) {
+        return struct.get(entry_timeout$LAYOUT, entry_timeout$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * double entry_timeout;
+     * {@snippet lang=c :
+     * double entry_timeout
      * }
      */
-    public static void entry_timeout$set(MemorySegment seg, double x) {
-        constants$11.const$3.set(seg, x);
+    public static void entry_timeout(MemorySegment struct, double fieldValue) {
+        struct.set(entry_timeout$LAYOUT, entry_timeout$OFFSET, fieldValue);
     }
-    public static double entry_timeout$get(MemorySegment seg, long index) {
-        return (double)constants$11.const$3.get(seg.asSlice(index*sizeof()));
-    }
-    public static void entry_timeout$set(MemorySegment seg, long index, double x) {
-        constants$11.const$3.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfDouble negative_timeout$LAYOUT = (OfDouble)$LAYOUT.select(groupElement("negative_timeout"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * double negative_timeout
+     * }
+     */
+    public static final OfDouble negative_timeout$layout() {
+        return negative_timeout$LAYOUT;
     }
-    public static VarHandle negative_timeout$VH() {
-        return constants$11.const$4;
+
+    private static final long negative_timeout$OFFSET = 32;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * double negative_timeout
+     * }
+     */
+    public static final long negative_timeout$offset() {
+        return negative_timeout$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * double negative_timeout;
+     * {@snippet lang=c :
+     * double negative_timeout
      * }
      */
-    public static double negative_timeout$get(MemorySegment seg) {
-        return (double)constants$11.const$4.get(seg);
+    public static double negative_timeout(MemorySegment struct) {
+        return struct.get(negative_timeout$LAYOUT, negative_timeout$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * double negative_timeout;
+     * {@snippet lang=c :
+     * double negative_timeout
      * }
      */
-    public static void negative_timeout$set(MemorySegment seg, double x) {
-        constants$11.const$4.set(seg, x);
-    }
-    public static double negative_timeout$get(MemorySegment seg, long index) {
-        return (double)constants$11.const$4.get(seg.asSlice(index*sizeof()));
+    public static void negative_timeout(MemorySegment struct, double fieldValue) {
+        struct.set(negative_timeout$LAYOUT, negative_timeout$OFFSET, fieldValue);
     }
-    public static void negative_timeout$set(MemorySegment seg, long index, double x) {
-        constants$11.const$4.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfDouble attr_timeout$LAYOUT = (OfDouble)$LAYOUT.select(groupElement("attr_timeout"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * double attr_timeout
+     * }
+     */
+    public static final OfDouble attr_timeout$layout() {
+        return attr_timeout$LAYOUT;
     }
-    public static VarHandle attr_timeout$VH() {
-        return constants$11.const$5;
+
+    private static final long attr_timeout$OFFSET = 40;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * double attr_timeout
+     * }
+     */
+    public static final long attr_timeout$offset() {
+        return attr_timeout$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * double attr_timeout;
+     * {@snippet lang=c :
+     * double attr_timeout
      * }
      */
-    public static double attr_timeout$get(MemorySegment seg) {
-        return (double)constants$11.const$5.get(seg);
+    public static double attr_timeout(MemorySegment struct) {
+        return struct.get(attr_timeout$LAYOUT, attr_timeout$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * double attr_timeout;
+     * {@snippet lang=c :
+     * double attr_timeout
      * }
      */
-    public static void attr_timeout$set(MemorySegment seg, double x) {
-        constants$11.const$5.set(seg, x);
-    }
-    public static double attr_timeout$get(MemorySegment seg, long index) {
-        return (double)constants$11.const$5.get(seg.asSlice(index*sizeof()));
+    public static void attr_timeout(MemorySegment struct, double fieldValue) {
+        struct.set(attr_timeout$LAYOUT, attr_timeout$OFFSET, fieldValue);
     }
-    public static void attr_timeout$set(MemorySegment seg, long index, double x) {
-        constants$11.const$5.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt intr$LAYOUT = (OfInt)$LAYOUT.select(groupElement("intr"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int intr
+     * }
+     */
+    public static final OfInt intr$layout() {
+        return intr$LAYOUT;
     }
-    public static VarHandle intr$VH() {
-        return constants$12.const$0;
+
+    private static final long intr$OFFSET = 48;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int intr
+     * }
+     */
+    public static final long intr$offset() {
+        return intr$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int intr;
+     * {@snippet lang=c :
+     * int intr
      * }
      */
-    public static int intr$get(MemorySegment seg) {
-        return (int)constants$12.const$0.get(seg);
+    public static int intr(MemorySegment struct) {
+        return struct.get(intr$LAYOUT, intr$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int intr;
+     * {@snippet lang=c :
+     * int intr
      * }
      */
-    public static void intr$set(MemorySegment seg, int x) {
-        constants$12.const$0.set(seg, x);
+    public static void intr(MemorySegment struct, int fieldValue) {
+        struct.set(intr$LAYOUT, intr$OFFSET, fieldValue);
     }
-    public static int intr$get(MemorySegment seg, long index) {
-        return (int)constants$12.const$0.get(seg.asSlice(index*sizeof()));
-    }
-    public static void intr$set(MemorySegment seg, long index, int x) {
-        constants$12.const$0.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt intr_signal$LAYOUT = (OfInt)$LAYOUT.select(groupElement("intr_signal"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int intr_signal
+     * }
+     */
+    public static final OfInt intr_signal$layout() {
+        return intr_signal$LAYOUT;
     }
-    public static VarHandle intr_signal$VH() {
-        return constants$12.const$1;
+
+    private static final long intr_signal$OFFSET = 52;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int intr_signal
+     * }
+     */
+    public static final long intr_signal$offset() {
+        return intr_signal$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int intr_signal;
+     * {@snippet lang=c :
+     * int intr_signal
      * }
      */
-    public static int intr_signal$get(MemorySegment seg) {
-        return (int)constants$12.const$1.get(seg);
+    public static int intr_signal(MemorySegment struct) {
+        return struct.get(intr_signal$LAYOUT, intr_signal$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int intr_signal;
+     * {@snippet lang=c :
+     * int intr_signal
      * }
      */
-    public static void intr_signal$set(MemorySegment seg, int x) {
-        constants$12.const$1.set(seg, x);
-    }
-    public static int intr_signal$get(MemorySegment seg, long index) {
-        return (int)constants$12.const$1.get(seg.asSlice(index*sizeof()));
+    public static void intr_signal(MemorySegment struct, int fieldValue) {
+        struct.set(intr_signal$LAYOUT, intr_signal$OFFSET, fieldValue);
     }
-    public static void intr_signal$set(MemorySegment seg, long index, int x) {
-        constants$12.const$1.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt remember$LAYOUT = (OfInt)$LAYOUT.select(groupElement("remember"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int remember
+     * }
+     */
+    public static final OfInt remember$layout() {
+        return remember$LAYOUT;
     }
-    public static VarHandle remember$VH() {
-        return constants$12.const$2;
+
+    private static final long remember$OFFSET = 56;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int remember
+     * }
+     */
+    public static final long remember$offset() {
+        return remember$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int remember;
+     * {@snippet lang=c :
+     * int remember
      * }
      */
-    public static int remember$get(MemorySegment seg) {
-        return (int)constants$12.const$2.get(seg);
+    public static int remember(MemorySegment struct) {
+        return struct.get(remember$LAYOUT, remember$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int remember;
+     * {@snippet lang=c :
+     * int remember
      * }
      */
-    public static void remember$set(MemorySegment seg, int x) {
-        constants$12.const$2.set(seg, x);
-    }
-    public static int remember$get(MemorySegment seg, long index) {
-        return (int)constants$12.const$2.get(seg.asSlice(index*sizeof()));
+    public static void remember(MemorySegment struct, int fieldValue) {
+        struct.set(remember$LAYOUT, remember$OFFSET, fieldValue);
     }
-    public static void remember$set(MemorySegment seg, long index, int x) {
-        constants$12.const$2.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt hard_remove$LAYOUT = (OfInt)$LAYOUT.select(groupElement("hard_remove"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int hard_remove
+     * }
+     */
+    public static final OfInt hard_remove$layout() {
+        return hard_remove$LAYOUT;
     }
-    public static VarHandle hard_remove$VH() {
-        return constants$12.const$3;
+
+    private static final long hard_remove$OFFSET = 60;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int hard_remove
+     * }
+     */
+    public static final long hard_remove$offset() {
+        return hard_remove$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int hard_remove;
+     * {@snippet lang=c :
+     * int hard_remove
      * }
      */
-    public static int hard_remove$get(MemorySegment seg) {
-        return (int)constants$12.const$3.get(seg);
+    public static int hard_remove(MemorySegment struct) {
+        return struct.get(hard_remove$LAYOUT, hard_remove$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int hard_remove;
+     * {@snippet lang=c :
+     * int hard_remove
      * }
      */
-    public static void hard_remove$set(MemorySegment seg, int x) {
-        constants$12.const$3.set(seg, x);
-    }
-    public static int hard_remove$get(MemorySegment seg, long index) {
-        return (int)constants$12.const$3.get(seg.asSlice(index*sizeof()));
+    public static void hard_remove(MemorySegment struct, int fieldValue) {
+        struct.set(hard_remove$LAYOUT, hard_remove$OFFSET, fieldValue);
     }
-    public static void hard_remove$set(MemorySegment seg, long index, int x) {
-        constants$12.const$3.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt use_ino$LAYOUT = (OfInt)$LAYOUT.select(groupElement("use_ino"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int use_ino
+     * }
+     */
+    public static final OfInt use_ino$layout() {
+        return use_ino$LAYOUT;
     }
-    public static VarHandle use_ino$VH() {
-        return constants$12.const$4;
+
+    private static final long use_ino$OFFSET = 64;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int use_ino
+     * }
+     */
+    public static final long use_ino$offset() {
+        return use_ino$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int use_ino;
+     * {@snippet lang=c :
+     * int use_ino
      * }
      */
-    public static int use_ino$get(MemorySegment seg) {
-        return (int)constants$12.const$4.get(seg);
+    public static int use_ino(MemorySegment struct) {
+        return struct.get(use_ino$LAYOUT, use_ino$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int use_ino;
+     * {@snippet lang=c :
+     * int use_ino
      * }
      */
-    public static void use_ino$set(MemorySegment seg, int x) {
-        constants$12.const$4.set(seg, x);
-    }
-    public static int use_ino$get(MemorySegment seg, long index) {
-        return (int)constants$12.const$4.get(seg.asSlice(index*sizeof()));
+    public static void use_ino(MemorySegment struct, int fieldValue) {
+        struct.set(use_ino$LAYOUT, use_ino$OFFSET, fieldValue);
     }
-    public static void use_ino$set(MemorySegment seg, long index, int x) {
-        constants$12.const$4.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt readdir_ino$LAYOUT = (OfInt)$LAYOUT.select(groupElement("readdir_ino"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int readdir_ino
+     * }
+     */
+    public static final OfInt readdir_ino$layout() {
+        return readdir_ino$LAYOUT;
     }
-    public static VarHandle readdir_ino$VH() {
-        return constants$12.const$5;
+
+    private static final long readdir_ino$OFFSET = 68;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int readdir_ino
+     * }
+     */
+    public static final long readdir_ino$offset() {
+        return readdir_ino$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int readdir_ino;
+     * {@snippet lang=c :
+     * int readdir_ino
      * }
      */
-    public static int readdir_ino$get(MemorySegment seg) {
-        return (int)constants$12.const$5.get(seg);
+    public static int readdir_ino(MemorySegment struct) {
+        return struct.get(readdir_ino$LAYOUT, readdir_ino$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int readdir_ino;
+     * {@snippet lang=c :
+     * int readdir_ino
      * }
      */
-    public static void readdir_ino$set(MemorySegment seg, int x) {
-        constants$12.const$5.set(seg, x);
-    }
-    public static int readdir_ino$get(MemorySegment seg, long index) {
-        return (int)constants$12.const$5.get(seg.asSlice(index*sizeof()));
+    public static void readdir_ino(MemorySegment struct, int fieldValue) {
+        struct.set(readdir_ino$LAYOUT, readdir_ino$OFFSET, fieldValue);
     }
-    public static void readdir_ino$set(MemorySegment seg, long index, int x) {
-        constants$12.const$5.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt direct_io$LAYOUT = (OfInt)$LAYOUT.select(groupElement("direct_io"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int direct_io
+     * }
+     */
+    public static final OfInt direct_io$layout() {
+        return direct_io$LAYOUT;
     }
-    public static VarHandle direct_io$VH() {
-        return constants$13.const$0;
+
+    private static final long direct_io$OFFSET = 72;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int direct_io
+     * }
+     */
+    public static final long direct_io$offset() {
+        return direct_io$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int direct_io;
+     * {@snippet lang=c :
+     * int direct_io
      * }
      */
-    public static int direct_io$get(MemorySegment seg) {
-        return (int)constants$13.const$0.get(seg);
+    public static int direct_io(MemorySegment struct) {
+        return struct.get(direct_io$LAYOUT, direct_io$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int direct_io;
+     * {@snippet lang=c :
+     * int direct_io
      * }
      */
-    public static void direct_io$set(MemorySegment seg, int x) {
-        constants$13.const$0.set(seg, x);
+    public static void direct_io(MemorySegment struct, int fieldValue) {
+        struct.set(direct_io$LAYOUT, direct_io$OFFSET, fieldValue);
     }
-    public static int direct_io$get(MemorySegment seg, long index) {
-        return (int)constants$13.const$0.get(seg.asSlice(index*sizeof()));
-    }
-    public static void direct_io$set(MemorySegment seg, long index, int x) {
-        constants$13.const$0.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt kernel_cache$LAYOUT = (OfInt)$LAYOUT.select(groupElement("kernel_cache"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int kernel_cache
+     * }
+     */
+    public static final OfInt kernel_cache$layout() {
+        return kernel_cache$LAYOUT;
     }
-    public static VarHandle kernel_cache$VH() {
-        return constants$13.const$1;
+
+    private static final long kernel_cache$OFFSET = 76;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int kernel_cache
+     * }
+     */
+    public static final long kernel_cache$offset() {
+        return kernel_cache$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int kernel_cache;
+     * {@snippet lang=c :
+     * int kernel_cache
      * }
      */
-    public static int kernel_cache$get(MemorySegment seg) {
-        return (int)constants$13.const$1.get(seg);
+    public static int kernel_cache(MemorySegment struct) {
+        return struct.get(kernel_cache$LAYOUT, kernel_cache$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int kernel_cache;
+     * {@snippet lang=c :
+     * int kernel_cache
      * }
      */
-    public static void kernel_cache$set(MemorySegment seg, int x) {
-        constants$13.const$1.set(seg, x);
-    }
-    public static int kernel_cache$get(MemorySegment seg, long index) {
-        return (int)constants$13.const$1.get(seg.asSlice(index*sizeof()));
+    public static void kernel_cache(MemorySegment struct, int fieldValue) {
+        struct.set(kernel_cache$LAYOUT, kernel_cache$OFFSET, fieldValue);
     }
-    public static void kernel_cache$set(MemorySegment seg, long index, int x) {
-        constants$13.const$1.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt auto_cache$LAYOUT = (OfInt)$LAYOUT.select(groupElement("auto_cache"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int auto_cache
+     * }
+     */
+    public static final OfInt auto_cache$layout() {
+        return auto_cache$LAYOUT;
     }
-    public static VarHandle auto_cache$VH() {
-        return constants$13.const$2;
+
+    private static final long auto_cache$OFFSET = 80;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int auto_cache
+     * }
+     */
+    public static final long auto_cache$offset() {
+        return auto_cache$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int auto_cache;
+     * {@snippet lang=c :
+     * int auto_cache
      * }
      */
-    public static int auto_cache$get(MemorySegment seg) {
-        return (int)constants$13.const$2.get(seg);
+    public static int auto_cache(MemorySegment struct) {
+        return struct.get(auto_cache$LAYOUT, auto_cache$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int auto_cache;
+     * {@snippet lang=c :
+     * int auto_cache
      * }
      */
-    public static void auto_cache$set(MemorySegment seg, int x) {
-        constants$13.const$2.set(seg, x);
-    }
-    public static int auto_cache$get(MemorySegment seg, long index) {
-        return (int)constants$13.const$2.get(seg.asSlice(index*sizeof()));
+    public static void auto_cache(MemorySegment struct, int fieldValue) {
+        struct.set(auto_cache$LAYOUT, auto_cache$OFFSET, fieldValue);
     }
-    public static void auto_cache$set(MemorySegment seg, long index, int x) {
-        constants$13.const$2.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt no_rofd_flush$LAYOUT = (OfInt)$LAYOUT.select(groupElement("no_rofd_flush"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int no_rofd_flush
+     * }
+     */
+    public static final OfInt no_rofd_flush$layout() {
+        return no_rofd_flush$LAYOUT;
     }
-    public static VarHandle no_rofd_flush$VH() {
-        return constants$13.const$3;
+
+    private static final long no_rofd_flush$OFFSET = 84;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int no_rofd_flush
+     * }
+     */
+    public static final long no_rofd_flush$offset() {
+        return no_rofd_flush$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int no_rofd_flush;
+     * {@snippet lang=c :
+     * int no_rofd_flush
      * }
      */
-    public static int no_rofd_flush$get(MemorySegment seg) {
-        return (int)constants$13.const$3.get(seg);
+    public static int no_rofd_flush(MemorySegment struct) {
+        return struct.get(no_rofd_flush$LAYOUT, no_rofd_flush$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int no_rofd_flush;
+     * {@snippet lang=c :
+     * int no_rofd_flush
      * }
      */
-    public static void no_rofd_flush$set(MemorySegment seg, int x) {
-        constants$13.const$3.set(seg, x);
-    }
-    public static int no_rofd_flush$get(MemorySegment seg, long index) {
-        return (int)constants$13.const$3.get(seg.asSlice(index*sizeof()));
+    public static void no_rofd_flush(MemorySegment struct, int fieldValue) {
+        struct.set(no_rofd_flush$LAYOUT, no_rofd_flush$OFFSET, fieldValue);
     }
-    public static void no_rofd_flush$set(MemorySegment seg, long index, int x) {
-        constants$13.const$3.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt ac_attr_timeout_set$LAYOUT = (OfInt)$LAYOUT.select(groupElement("ac_attr_timeout_set"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int ac_attr_timeout_set
+     * }
+     */
+    public static final OfInt ac_attr_timeout_set$layout() {
+        return ac_attr_timeout_set$LAYOUT;
     }
-    public static VarHandle ac_attr_timeout_set$VH() {
-        return constants$13.const$4;
+
+    private static final long ac_attr_timeout_set$OFFSET = 88;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int ac_attr_timeout_set
+     * }
+     */
+    public static final long ac_attr_timeout_set$offset() {
+        return ac_attr_timeout_set$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int ac_attr_timeout_set;
+     * {@snippet lang=c :
+     * int ac_attr_timeout_set
      * }
      */
-    public static int ac_attr_timeout_set$get(MemorySegment seg) {
-        return (int)constants$13.const$4.get(seg);
+    public static int ac_attr_timeout_set(MemorySegment struct) {
+        return struct.get(ac_attr_timeout_set$LAYOUT, ac_attr_timeout_set$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int ac_attr_timeout_set;
+     * {@snippet lang=c :
+     * int ac_attr_timeout_set
      * }
      */
-    public static void ac_attr_timeout_set$set(MemorySegment seg, int x) {
-        constants$13.const$4.set(seg, x);
+    public static void ac_attr_timeout_set(MemorySegment struct, int fieldValue) {
+        struct.set(ac_attr_timeout_set$LAYOUT, ac_attr_timeout_set$OFFSET, fieldValue);
     }
-    public static int ac_attr_timeout_set$get(MemorySegment seg, long index) {
-        return (int)constants$13.const$4.get(seg.asSlice(index*sizeof()));
-    }
-    public static void ac_attr_timeout_set$set(MemorySegment seg, long index, int x) {
-        constants$13.const$4.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfDouble ac_attr_timeout$LAYOUT = (OfDouble)$LAYOUT.select(groupElement("ac_attr_timeout"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * double ac_attr_timeout
+     * }
+     */
+    public static final OfDouble ac_attr_timeout$layout() {
+        return ac_attr_timeout$LAYOUT;
     }
-    public static VarHandle ac_attr_timeout$VH() {
-        return constants$13.const$5;
+
+    private static final long ac_attr_timeout$OFFSET = 96;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * double ac_attr_timeout
+     * }
+     */
+    public static final long ac_attr_timeout$offset() {
+        return ac_attr_timeout$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * double ac_attr_timeout;
+     * {@snippet lang=c :
+     * double ac_attr_timeout
      * }
      */
-    public static double ac_attr_timeout$get(MemorySegment seg) {
-        return (double)constants$13.const$5.get(seg);
+    public static double ac_attr_timeout(MemorySegment struct) {
+        return struct.get(ac_attr_timeout$LAYOUT, ac_attr_timeout$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * double ac_attr_timeout;
+     * {@snippet lang=c :
+     * double ac_attr_timeout
      * }
      */
-    public static void ac_attr_timeout$set(MemorySegment seg, double x) {
-        constants$13.const$5.set(seg, x);
-    }
-    public static double ac_attr_timeout$get(MemorySegment seg, long index) {
-        return (double)constants$13.const$5.get(seg.asSlice(index*sizeof()));
+    public static void ac_attr_timeout(MemorySegment struct, double fieldValue) {
+        struct.set(ac_attr_timeout$LAYOUT, ac_attr_timeout$OFFSET, fieldValue);
     }
-    public static void ac_attr_timeout$set(MemorySegment seg, long index, double x) {
-        constants$13.const$5.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt nullpath_ok$LAYOUT = (OfInt)$LAYOUT.select(groupElement("nullpath_ok"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int nullpath_ok
+     * }
+     */
+    public static final OfInt nullpath_ok$layout() {
+        return nullpath_ok$LAYOUT;
     }
-    public static VarHandle nullpath_ok$VH() {
-        return constants$14.const$0;
+
+    private static final long nullpath_ok$OFFSET = 104;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int nullpath_ok
+     * }
+     */
+    public static final long nullpath_ok$offset() {
+        return nullpath_ok$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int nullpath_ok;
+     * {@snippet lang=c :
+     * int nullpath_ok
      * }
      */
-    public static int nullpath_ok$get(MemorySegment seg) {
-        return (int)constants$14.const$0.get(seg);
+    public static int nullpath_ok(MemorySegment struct) {
+        return struct.get(nullpath_ok$LAYOUT, nullpath_ok$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int nullpath_ok;
+     * {@snippet lang=c :
+     * int nullpath_ok
      * }
      */
-    public static void nullpath_ok$set(MemorySegment seg, int x) {
-        constants$14.const$0.set(seg, x);
+    public static void nullpath_ok(MemorySegment struct, int fieldValue) {
+        struct.set(nullpath_ok$LAYOUT, nullpath_ok$OFFSET, fieldValue);
     }
-    public static int nullpath_ok$get(MemorySegment seg, long index) {
-        return (int)constants$14.const$0.get(seg.asSlice(index*sizeof()));
-    }
-    public static void nullpath_ok$set(MemorySegment seg, long index, int x) {
-        constants$14.const$0.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt show_help$LAYOUT = (OfInt)$LAYOUT.select(groupElement("show_help"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int show_help
+     * }
+     */
+    public static final OfInt show_help$layout() {
+        return show_help$LAYOUT;
     }
-    public static VarHandle show_help$VH() {
-        return constants$14.const$1;
+
+    private static final long show_help$OFFSET = 108;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int show_help
+     * }
+     */
+    public static final long show_help$offset() {
+        return show_help$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int show_help;
+     * {@snippet lang=c :
+     * int show_help
      * }
      */
-    public static int show_help$get(MemorySegment seg) {
-        return (int)constants$14.const$1.get(seg);
+    public static int show_help(MemorySegment struct) {
+        return struct.get(show_help$LAYOUT, show_help$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int show_help;
+     * {@snippet lang=c :
+     * int show_help
      * }
      */
-    public static void show_help$set(MemorySegment seg, int x) {
-        constants$14.const$1.set(seg, x);
-    }
-    public static int show_help$get(MemorySegment seg, long index) {
-        return (int)constants$14.const$1.get(seg.asSlice(index*sizeof()));
+    public static void show_help(MemorySegment struct, int fieldValue) {
+        struct.set(show_help$LAYOUT, show_help$OFFSET, fieldValue);
     }
-    public static void show_help$set(MemorySegment seg, long index, int x) {
-        constants$14.const$1.set(seg.asSlice(index*sizeof()), x);
+
+    private static final AddressLayout modules$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("modules"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * char *modules
+     * }
+     */
+    public static final AddressLayout modules$layout() {
+        return modules$LAYOUT;
     }
-    public static VarHandle modules$VH() {
-        return constants$14.const$2;
+
+    private static final long modules$OFFSET = 112;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * char *modules
+     * }
+     */
+    public static final long modules$offset() {
+        return modules$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * char* modules;
+     * {@snippet lang=c :
+     * char *modules
      * }
      */
-    public static MemorySegment modules$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$14.const$2.get(seg);
+    public static MemorySegment modules(MemorySegment struct) {
+        return struct.get(modules$LAYOUT, modules$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * char* modules;
+     * {@snippet lang=c :
+     * char *modules
      * }
      */
-    public static void modules$set(MemorySegment seg, MemorySegment x) {
-        constants$14.const$2.set(seg, x);
-    }
-    public static MemorySegment modules$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$14.const$2.get(seg.asSlice(index*sizeof()));
+    public static void modules(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(modules$LAYOUT, modules$OFFSET, fieldValue);
     }
-    public static void modules$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$14.const$2.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt debug$LAYOUT = (OfInt)$LAYOUT.select(groupElement("debug"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int debug
+     * }
+     */
+    public static final OfInt debug$layout() {
+        return debug$LAYOUT;
     }
-    public static VarHandle debug$VH() {
-        return constants$14.const$3;
+
+    private static final long debug$OFFSET = 120;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int debug
+     * }
+     */
+    public static final long debug$offset() {
+        return debug$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int debug;
+     * {@snippet lang=c :
+     * int debug
      * }
      */
-    public static int debug$get(MemorySegment seg) {
-        return (int)constants$14.const$3.get(seg);
+    public static int debug(MemorySegment struct) {
+        return struct.get(debug$LAYOUT, debug$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int debug;
+     * {@snippet lang=c :
+     * int debug
      * }
      */
-    public static void debug$set(MemorySegment seg, int x) {
-        constants$14.const$3.set(seg, x);
+    public static void debug(MemorySegment struct, int fieldValue) {
+        struct.set(debug$LAYOUT, debug$OFFSET, fieldValue);
+    }
+
+    /**
+     * Obtains a slice of {@code arrayParam} which selects the array element at {@code index}.
+     * The returned segment has address {@code arrayParam.address() + index * layout().byteSize()}
+     */
+    public static MemorySegment asSlice(MemorySegment array, long index) {
+        return array.asSlice(layout().byteSize() * index);
+    }
+
+    /**
+     * The size (in bytes) of this struct
+     */
+    public static long sizeof() { return layout().byteSize(); }
+
+    /**
+     * Allocate a segment of size {@code layout().byteSize()} using {@code allocator}
+     */
+    public static MemorySegment allocate(SegmentAllocator allocator) {
+        return allocator.allocate(layout());
     }
-    public static int debug$get(MemorySegment seg, long index) {
-        return (int)constants$14.const$3.get(seg.asSlice(index*sizeof()));
+
+    /**
+     * Allocate an array of size {@code elementCount} using {@code allocator}.
+     * The returned segment has size {@code elementCount * layout().byteSize()}.
+     */
+    public static MemorySegment allocateArray(long elementCount, SegmentAllocator allocator) {
+        return allocator.allocate(MemoryLayout.sequenceLayout(elementCount, layout()));
     }
-    public static void debug$set(MemorySegment seg, long index, int x) {
-        constants$14.const$3.set(seg.asSlice(index*sizeof()), x);
+
+    /**
+     * Reinterprets {@code addr} using target {@code arena} and {@code cleanupAction) (if any).
+     * The returned segment has size {@code layout().byteSize()}
+     */
+    public static MemorySegment reinterpret(MemorySegment addr, Arena arena, Consumer<MemorySegment> cleanup) {
+        return reinterpret(addr, 1, arena, cleanup);
     }
-    public static long sizeof() { return $LAYOUT().byteSize(); }
-    public static MemorySegment allocate(SegmentAllocator allocator) { return allocator.allocate($LAYOUT()); }
-    public static MemorySegment allocateArray(long len, SegmentAllocator allocator) {
-        return allocator.allocate(MemoryLayout.sequenceLayout(len, $LAYOUT()));
+
+    /**
+     * Reinterprets {@code addr} using target {@code arena} and {@code cleanupAction) (if any).
+     * The returned segment has size {@code elementCount * layout().byteSize()}
+     */
+    public static MemorySegment reinterpret(MemorySegment addr, long elementCount, Arena arena, Consumer<MemorySegment> cleanup) {
+        return addr.reinterpret(layout().byteSize() * elementCount, arena, cleanup);
     }
-    public static MemorySegment ofAddress(MemorySegment addr, Arena scope) { return RuntimeHelper.asArray(addr, $LAYOUT(), 1, scope); }
 }
 
-
diff --git a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/fuse_conn_info.java b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/fuse_conn_info.java
index 0b5bddb2..e677e612 100644
--- a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/fuse_conn_info.java
+++ b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/fuse_conn_info.java
@@ -2,13 +2,18 @@
 
 package org.cryptomator.jfuse.linux.amd64.extr.fuse3;
 
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
+import java.lang.invoke.*;
 import java.lang.foreign.*;
+import java.nio.ByteOrder;
+import java.util.*;
+import java.util.function.*;
+import java.util.stream.*;
+
 import static java.lang.foreign.ValueLayout.*;
+import static java.lang.foreign.MemoryLayout.PathElement.*;
+
 /**
- * {@snippet :
+ * {@snippet lang=c :
  * struct fuse_conn_info {
  *     unsigned int proto_major;
  *     unsigned int proto_minor;
@@ -21,293 +26,595 @@
  *     unsigned int congestion_threshold;
  *     unsigned int time_gran;
  *     unsigned int reserved[22];
- * };
+ * }
  * }
  */
 public class fuse_conn_info {
 
-    public static MemoryLayout $LAYOUT() {
-        return constants$2.const$3;
+    fuse_conn_info() {
+        // Should not be called directly
     }
-    public static VarHandle proto_major$VH() {
-        return constants$2.const$4;
+
+    private static final GroupLayout $LAYOUT = MemoryLayout.structLayout(
+        fuse_h.C_INT.withName("proto_major"),
+        fuse_h.C_INT.withName("proto_minor"),
+        fuse_h.C_INT.withName("max_write"),
+        fuse_h.C_INT.withName("max_read"),
+        fuse_h.C_INT.withName("max_readahead"),
+        fuse_h.C_INT.withName("capable"),
+        fuse_h.C_INT.withName("want"),
+        fuse_h.C_INT.withName("max_background"),
+        fuse_h.C_INT.withName("congestion_threshold"),
+        fuse_h.C_INT.withName("time_gran"),
+        MemoryLayout.sequenceLayout(22, fuse_h.C_INT).withName("reserved")
+    ).withName("fuse_conn_info");
+
+    /**
+     * The layout of this struct
+     */
+    public static final GroupLayout layout() {
+        return $LAYOUT;
     }
+
+    private static final OfInt proto_major$LAYOUT = (OfInt)$LAYOUT.select(groupElement("proto_major"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * unsigned int proto_major
+     * }
+     */
+    public static final OfInt proto_major$layout() {
+        return proto_major$LAYOUT;
+    }
+
+    private static final long proto_major$OFFSET = 0;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * unsigned int proto_major
+     * }
+     */
+    public static final long proto_major$offset() {
+        return proto_major$OFFSET;
+    }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned int proto_major;
+     * {@snippet lang=c :
+     * unsigned int proto_major
      * }
      */
-    public static int proto_major$get(MemorySegment seg) {
-        return (int)constants$2.const$4.get(seg);
+    public static int proto_major(MemorySegment struct) {
+        return struct.get(proto_major$LAYOUT, proto_major$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned int proto_major;
+     * {@snippet lang=c :
+     * unsigned int proto_major
      * }
      */
-    public static void proto_major$set(MemorySegment seg, int x) {
-        constants$2.const$4.set(seg, x);
-    }
-    public static int proto_major$get(MemorySegment seg, long index) {
-        return (int)constants$2.const$4.get(seg.asSlice(index*sizeof()));
+    public static void proto_major(MemorySegment struct, int fieldValue) {
+        struct.set(proto_major$LAYOUT, proto_major$OFFSET, fieldValue);
     }
-    public static void proto_major$set(MemorySegment seg, long index, int x) {
-        constants$2.const$4.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt proto_minor$LAYOUT = (OfInt)$LAYOUT.select(groupElement("proto_minor"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * unsigned int proto_minor
+     * }
+     */
+    public static final OfInt proto_minor$layout() {
+        return proto_minor$LAYOUT;
     }
-    public static VarHandle proto_minor$VH() {
-        return constants$2.const$5;
+
+    private static final long proto_minor$OFFSET = 4;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * unsigned int proto_minor
+     * }
+     */
+    public static final long proto_minor$offset() {
+        return proto_minor$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned int proto_minor;
+     * {@snippet lang=c :
+     * unsigned int proto_minor
      * }
      */
-    public static int proto_minor$get(MemorySegment seg) {
-        return (int)constants$2.const$5.get(seg);
+    public static int proto_minor(MemorySegment struct) {
+        return struct.get(proto_minor$LAYOUT, proto_minor$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned int proto_minor;
+     * {@snippet lang=c :
+     * unsigned int proto_minor
      * }
      */
-    public static void proto_minor$set(MemorySegment seg, int x) {
-        constants$2.const$5.set(seg, x);
-    }
-    public static int proto_minor$get(MemorySegment seg, long index) {
-        return (int)constants$2.const$5.get(seg.asSlice(index*sizeof()));
+    public static void proto_minor(MemorySegment struct, int fieldValue) {
+        struct.set(proto_minor$LAYOUT, proto_minor$OFFSET, fieldValue);
     }
-    public static void proto_minor$set(MemorySegment seg, long index, int x) {
-        constants$2.const$5.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt max_write$LAYOUT = (OfInt)$LAYOUT.select(groupElement("max_write"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * unsigned int max_write
+     * }
+     */
+    public static final OfInt max_write$layout() {
+        return max_write$LAYOUT;
     }
-    public static VarHandle max_write$VH() {
-        return constants$3.const$0;
+
+    private static final long max_write$OFFSET = 8;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * unsigned int max_write
+     * }
+     */
+    public static final long max_write$offset() {
+        return max_write$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned int max_write;
+     * {@snippet lang=c :
+     * unsigned int max_write
      * }
      */
-    public static int max_write$get(MemorySegment seg) {
-        return (int)constants$3.const$0.get(seg);
+    public static int max_write(MemorySegment struct) {
+        return struct.get(max_write$LAYOUT, max_write$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned int max_write;
+     * {@snippet lang=c :
+     * unsigned int max_write
      * }
      */
-    public static void max_write$set(MemorySegment seg, int x) {
-        constants$3.const$0.set(seg, x);
-    }
-    public static int max_write$get(MemorySegment seg, long index) {
-        return (int)constants$3.const$0.get(seg.asSlice(index*sizeof()));
+    public static void max_write(MemorySegment struct, int fieldValue) {
+        struct.set(max_write$LAYOUT, max_write$OFFSET, fieldValue);
     }
-    public static void max_write$set(MemorySegment seg, long index, int x) {
-        constants$3.const$0.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt max_read$LAYOUT = (OfInt)$LAYOUT.select(groupElement("max_read"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * unsigned int max_read
+     * }
+     */
+    public static final OfInt max_read$layout() {
+        return max_read$LAYOUT;
     }
-    public static VarHandle max_read$VH() {
-        return constants$3.const$1;
+
+    private static final long max_read$OFFSET = 12;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * unsigned int max_read
+     * }
+     */
+    public static final long max_read$offset() {
+        return max_read$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned int max_read;
+     * {@snippet lang=c :
+     * unsigned int max_read
      * }
      */
-    public static int max_read$get(MemorySegment seg) {
-        return (int)constants$3.const$1.get(seg);
+    public static int max_read(MemorySegment struct) {
+        return struct.get(max_read$LAYOUT, max_read$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned int max_read;
+     * {@snippet lang=c :
+     * unsigned int max_read
      * }
      */
-    public static void max_read$set(MemorySegment seg, int x) {
-        constants$3.const$1.set(seg, x);
-    }
-    public static int max_read$get(MemorySegment seg, long index) {
-        return (int)constants$3.const$1.get(seg.asSlice(index*sizeof()));
+    public static void max_read(MemorySegment struct, int fieldValue) {
+        struct.set(max_read$LAYOUT, max_read$OFFSET, fieldValue);
     }
-    public static void max_read$set(MemorySegment seg, long index, int x) {
-        constants$3.const$1.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt max_readahead$LAYOUT = (OfInt)$LAYOUT.select(groupElement("max_readahead"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * unsigned int max_readahead
+     * }
+     */
+    public static final OfInt max_readahead$layout() {
+        return max_readahead$LAYOUT;
     }
-    public static VarHandle max_readahead$VH() {
-        return constants$3.const$2;
+
+    private static final long max_readahead$OFFSET = 16;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * unsigned int max_readahead
+     * }
+     */
+    public static final long max_readahead$offset() {
+        return max_readahead$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned int max_readahead;
+     * {@snippet lang=c :
+     * unsigned int max_readahead
      * }
      */
-    public static int max_readahead$get(MemorySegment seg) {
-        return (int)constants$3.const$2.get(seg);
+    public static int max_readahead(MemorySegment struct) {
+        return struct.get(max_readahead$LAYOUT, max_readahead$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned int max_readahead;
+     * {@snippet lang=c :
+     * unsigned int max_readahead
      * }
      */
-    public static void max_readahead$set(MemorySegment seg, int x) {
-        constants$3.const$2.set(seg, x);
+    public static void max_readahead(MemorySegment struct, int fieldValue) {
+        struct.set(max_readahead$LAYOUT, max_readahead$OFFSET, fieldValue);
     }
-    public static int max_readahead$get(MemorySegment seg, long index) {
-        return (int)constants$3.const$2.get(seg.asSlice(index*sizeof()));
-    }
-    public static void max_readahead$set(MemorySegment seg, long index, int x) {
-        constants$3.const$2.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt capable$LAYOUT = (OfInt)$LAYOUT.select(groupElement("capable"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * unsigned int capable
+     * }
+     */
+    public static final OfInt capable$layout() {
+        return capable$LAYOUT;
     }
-    public static VarHandle capable$VH() {
-        return constants$3.const$3;
+
+    private static final long capable$OFFSET = 20;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * unsigned int capable
+     * }
+     */
+    public static final long capable$offset() {
+        return capable$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned int capable;
+     * {@snippet lang=c :
+     * unsigned int capable
      * }
      */
-    public static int capable$get(MemorySegment seg) {
-        return (int)constants$3.const$3.get(seg);
+    public static int capable(MemorySegment struct) {
+        return struct.get(capable$LAYOUT, capable$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned int capable;
+     * {@snippet lang=c :
+     * unsigned int capable
      * }
      */
-    public static void capable$set(MemorySegment seg, int x) {
-        constants$3.const$3.set(seg, x);
-    }
-    public static int capable$get(MemorySegment seg, long index) {
-        return (int)constants$3.const$3.get(seg.asSlice(index*sizeof()));
+    public static void capable(MemorySegment struct, int fieldValue) {
+        struct.set(capable$LAYOUT, capable$OFFSET, fieldValue);
     }
-    public static void capable$set(MemorySegment seg, long index, int x) {
-        constants$3.const$3.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt want$LAYOUT = (OfInt)$LAYOUT.select(groupElement("want"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * unsigned int want
+     * }
+     */
+    public static final OfInt want$layout() {
+        return want$LAYOUT;
     }
-    public static VarHandle want$VH() {
-        return constants$3.const$4;
+
+    private static final long want$OFFSET = 24;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * unsigned int want
+     * }
+     */
+    public static final long want$offset() {
+        return want$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned int want;
+     * {@snippet lang=c :
+     * unsigned int want
      * }
      */
-    public static int want$get(MemorySegment seg) {
-        return (int)constants$3.const$4.get(seg);
+    public static int want(MemorySegment struct) {
+        return struct.get(want$LAYOUT, want$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned int want;
+     * {@snippet lang=c :
+     * unsigned int want
      * }
      */
-    public static void want$set(MemorySegment seg, int x) {
-        constants$3.const$4.set(seg, x);
+    public static void want(MemorySegment struct, int fieldValue) {
+        struct.set(want$LAYOUT, want$OFFSET, fieldValue);
     }
-    public static int want$get(MemorySegment seg, long index) {
-        return (int)constants$3.const$4.get(seg.asSlice(index*sizeof()));
-    }
-    public static void want$set(MemorySegment seg, long index, int x) {
-        constants$3.const$4.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt max_background$LAYOUT = (OfInt)$LAYOUT.select(groupElement("max_background"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * unsigned int max_background
+     * }
+     */
+    public static final OfInt max_background$layout() {
+        return max_background$LAYOUT;
     }
-    public static VarHandle max_background$VH() {
-        return constants$3.const$5;
+
+    private static final long max_background$OFFSET = 28;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * unsigned int max_background
+     * }
+     */
+    public static final long max_background$offset() {
+        return max_background$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned int max_background;
+     * {@snippet lang=c :
+     * unsigned int max_background
      * }
      */
-    public static int max_background$get(MemorySegment seg) {
-        return (int)constants$3.const$5.get(seg);
+    public static int max_background(MemorySegment struct) {
+        return struct.get(max_background$LAYOUT, max_background$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned int max_background;
+     * {@snippet lang=c :
+     * unsigned int max_background
      * }
      */
-    public static void max_background$set(MemorySegment seg, int x) {
-        constants$3.const$5.set(seg, x);
-    }
-    public static int max_background$get(MemorySegment seg, long index) {
-        return (int)constants$3.const$5.get(seg.asSlice(index*sizeof()));
+    public static void max_background(MemorySegment struct, int fieldValue) {
+        struct.set(max_background$LAYOUT, max_background$OFFSET, fieldValue);
     }
-    public static void max_background$set(MemorySegment seg, long index, int x) {
-        constants$3.const$5.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt congestion_threshold$LAYOUT = (OfInt)$LAYOUT.select(groupElement("congestion_threshold"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * unsigned int congestion_threshold
+     * }
+     */
+    public static final OfInt congestion_threshold$layout() {
+        return congestion_threshold$LAYOUT;
     }
-    public static VarHandle congestion_threshold$VH() {
-        return constants$4.const$0;
+
+    private static final long congestion_threshold$OFFSET = 32;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * unsigned int congestion_threshold
+     * }
+     */
+    public static final long congestion_threshold$offset() {
+        return congestion_threshold$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned int congestion_threshold;
+     * {@snippet lang=c :
+     * unsigned int congestion_threshold
      * }
      */
-    public static int congestion_threshold$get(MemorySegment seg) {
-        return (int)constants$4.const$0.get(seg);
+    public static int congestion_threshold(MemorySegment struct) {
+        return struct.get(congestion_threshold$LAYOUT, congestion_threshold$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned int congestion_threshold;
+     * {@snippet lang=c :
+     * unsigned int congestion_threshold
      * }
      */
-    public static void congestion_threshold$set(MemorySegment seg, int x) {
-        constants$4.const$0.set(seg, x);
+    public static void congestion_threshold(MemorySegment struct, int fieldValue) {
+        struct.set(congestion_threshold$LAYOUT, congestion_threshold$OFFSET, fieldValue);
     }
-    public static int congestion_threshold$get(MemorySegment seg, long index) {
-        return (int)constants$4.const$0.get(seg.asSlice(index*sizeof()));
+
+    private static final OfInt time_gran$LAYOUT = (OfInt)$LAYOUT.select(groupElement("time_gran"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * unsigned int time_gran
+     * }
+     */
+    public static final OfInt time_gran$layout() {
+        return time_gran$LAYOUT;
     }
-    public static void congestion_threshold$set(MemorySegment seg, long index, int x) {
-        constants$4.const$0.set(seg.asSlice(index*sizeof()), x);
+
+    private static final long time_gran$OFFSET = 36;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * unsigned int time_gran
+     * }
+     */
+    public static final long time_gran$offset() {
+        return time_gran$OFFSET;
     }
-    public static VarHandle time_gran$VH() {
-        return constants$4.const$1;
+
+    /**
+     * Getter for field:
+     * {@snippet lang=c :
+     * unsigned int time_gran
+     * }
+     */
+    public static int time_gran(MemorySegment struct) {
+        return struct.get(time_gran$LAYOUT, time_gran$OFFSET);
     }
+
+    /**
+     * Setter for field:
+     * {@snippet lang=c :
+     * unsigned int time_gran
+     * }
+     */
+    public static void time_gran(MemorySegment struct, int fieldValue) {
+        struct.set(time_gran$LAYOUT, time_gran$OFFSET, fieldValue);
+    }
+
+    private static final SequenceLayout reserved$LAYOUT = (SequenceLayout)$LAYOUT.select(groupElement("reserved"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * unsigned int reserved[22]
+     * }
+     */
+    public static final SequenceLayout reserved$layout() {
+        return reserved$LAYOUT;
+    }
+
+    private static final long reserved$OFFSET = 40;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * unsigned int reserved[22]
+     * }
+     */
+    public static final long reserved$offset() {
+        return reserved$OFFSET;
+    }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned int time_gran;
+     * {@snippet lang=c :
+     * unsigned int reserved[22]
      * }
      */
-    public static int time_gran$get(MemorySegment seg) {
-        return (int)constants$4.const$1.get(seg);
+    public static MemorySegment reserved(MemorySegment struct) {
+        return struct.asSlice(reserved$OFFSET, reserved$LAYOUT.byteSize());
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned int time_gran;
+     * {@snippet lang=c :
+     * unsigned int reserved[22]
      * }
      */
-    public static void time_gran$set(MemorySegment seg, int x) {
-        constants$4.const$1.set(seg, x);
+    public static void reserved(MemorySegment struct, MemorySegment fieldValue) {
+        MemorySegment.copy(fieldValue, 0L, struct, reserved$OFFSET, reserved$LAYOUT.byteSize());
     }
-    public static int time_gran$get(MemorySegment seg, long index) {
-        return (int)constants$4.const$1.get(seg.asSlice(index*sizeof()));
+
+    private static long[] reserved$DIMS = { 22 };
+
+    /**
+     * Dimensions for array field:
+     * {@snippet lang=c :
+     * unsigned int reserved[22]
+     * }
+     */
+    public static long[] reserved$dimensions() {
+        return reserved$DIMS;
     }
-    public static void time_gran$set(MemorySegment seg, long index, int x) {
-        constants$4.const$1.set(seg.asSlice(index*sizeof()), x);
+    private static final VarHandle reserved$ELEM_HANDLE = reserved$LAYOUT.varHandle(sequenceElement());
+
+    /**
+     * Indexed getter for field:
+     * {@snippet lang=c :
+     * unsigned int reserved[22]
+     * }
+     */
+    public static int reserved(MemorySegment struct, long index0) {
+        return (int)reserved$ELEM_HANDLE.get(struct, 0L, index0);
     }
-    public static MemorySegment reserved$slice(MemorySegment seg) {
-        return seg.asSlice(40, 88);
+
+    /**
+     * Indexed setter for field:
+     * {@snippet lang=c :
+     * unsigned int reserved[22]
+     * }
+     */
+    public static void reserved(MemorySegment struct, long index0, int fieldValue) {
+        reserved$ELEM_HANDLE.set(struct, 0L, index0, fieldValue);
     }
-    public static long sizeof() { return $LAYOUT().byteSize(); }
-    public static MemorySegment allocate(SegmentAllocator allocator) { return allocator.allocate($LAYOUT()); }
-    public static MemorySegment allocateArray(long len, SegmentAllocator allocator) {
-        return allocator.allocate(MemoryLayout.sequenceLayout(len, $LAYOUT()));
+
+    /**
+     * Obtains a slice of {@code arrayParam} which selects the array element at {@code index}.
+     * The returned segment has address {@code arrayParam.address() + index * layout().byteSize()}
+     */
+    public static MemorySegment asSlice(MemorySegment array, long index) {
+        return array.asSlice(layout().byteSize() * index);
+    }
+
+    /**
+     * The size (in bytes) of this struct
+     */
+    public static long sizeof() { return layout().byteSize(); }
+
+    /**
+     * Allocate a segment of size {@code layout().byteSize()} using {@code allocator}
+     */
+    public static MemorySegment allocate(SegmentAllocator allocator) {
+        return allocator.allocate(layout());
     }
-    public static MemorySegment ofAddress(MemorySegment addr, Arena scope) { return RuntimeHelper.asArray(addr, $LAYOUT(), 1, scope); }
-}
 
+    /**
+     * Allocate an array of size {@code elementCount} using {@code allocator}.
+     * The returned segment has size {@code elementCount * layout().byteSize()}.
+     */
+    public static MemorySegment allocateArray(long elementCount, SegmentAllocator allocator) {
+        return allocator.allocate(MemoryLayout.sequenceLayout(elementCount, layout()));
+    }
+
+    /**
+     * Reinterprets {@code addr} using target {@code arena} and {@code cleanupAction) (if any).
+     * The returned segment has size {@code layout().byteSize()}
+     */
+    public static MemorySegment reinterpret(MemorySegment addr, Arena arena, Consumer<MemorySegment> cleanup) {
+        return reinterpret(addr, 1, arena, cleanup);
+    }
+
+    /**
+     * Reinterprets {@code addr} using target {@code arena} and {@code cleanupAction) (if any).
+     * The returned segment has size {@code elementCount * layout().byteSize()}
+     */
+    public static MemorySegment reinterpret(MemorySegment addr, long elementCount, Arena arena, Consumer<MemorySegment> cleanup) {
+        return addr.reinterpret(layout().byteSize() * elementCount, arena, cleanup);
+    }
+}
 
diff --git a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/fuse_file_info.java b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/fuse_file_info.java
index 95f965b3..91d065d4 100644
--- a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/fuse_file_info.java
+++ b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/fuse_file_info.java
@@ -2,150 +2,276 @@
 
 package org.cryptomator.jfuse.linux.amd64.extr.fuse3;
 
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
+import java.lang.invoke.*;
 import java.lang.foreign.*;
+import java.nio.ByteOrder;
+import java.util.*;
+import java.util.function.*;
+import java.util.stream.*;
+
 import static java.lang.foreign.ValueLayout.*;
+import static java.lang.foreign.MemoryLayout.PathElement.*;
+
 /**
- * {@snippet :
+ * {@snippet lang=c :
  * struct fuse_file_info {
  *     int flags;
- *      *     unsigned int writepage;
- *     unsigned int direct_io;
- *     unsigned int keep_cache;
- *     unsigned int flush;
- *     unsigned int nonseekable;
- *     unsigned int flock_release;
- *     unsigned int cache_readdir;
- *     unsigned int noflush;
- *     unsigned int padding;
- *     unsigned int padding2;
- *     unsigned long fh;
- *     unsigned long lock_owner;
- *     unsigned int poll_events;
- * };
+ *     unsigned int writepage : 1;
+ *     unsigned int direct_io : 1;
+ *     unsigned int keep_cache : 1;
+ *     unsigned int flush : 1;
+ *     unsigned int nonseekable : 1;
+ *     unsigned int flock_release : 1;
+ *     unsigned int cache_readdir : 1;
+ *     unsigned int noflush : 1;
+ *     unsigned int padding : 24;
+ *     unsigned int padding2 : 32;
+ *     uint64_t fh;
+ *     uint64_t lock_owner;
+ *     uint32_t poll_events;
+ * }
  * }
  */
 public class fuse_file_info {
 
-    public static MemoryLayout $LAYOUT() {
-        return constants$1.const$1;
+    fuse_file_info() {
+        // Should not be called directly
     }
-    public static VarHandle flags$VH() {
-        return constants$1.const$2;
+
+    private static final GroupLayout $LAYOUT = MemoryLayout.structLayout(
+        fuse_h.C_INT.withName("flags"),
+        MemoryLayout.paddingLayout(12),
+        fuse_h.C_LONG.withName("fh"),
+        fuse_h.C_LONG.withName("lock_owner"),
+        fuse_h.C_INT.withName("poll_events"),
+        MemoryLayout.paddingLayout(4)
+    ).withName("fuse_file_info");
+
+    /**
+     * The layout of this struct
+     */
+    public static final GroupLayout layout() {
+        return $LAYOUT;
+    }
+
+    private static final OfInt flags$LAYOUT = (OfInt)$LAYOUT.select(groupElement("flags"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int flags
+     * }
+     */
+    public static final OfInt flags$layout() {
+        return flags$LAYOUT;
+    }
+
+    private static final long flags$OFFSET = 0;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int flags
+     * }
+     */
+    public static final long flags$offset() {
+        return flags$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int flags;
+     * {@snippet lang=c :
+     * int flags
      * }
      */
-    public static int flags$get(MemorySegment seg) {
-        return (int)constants$1.const$2.get(seg);
+    public static int flags(MemorySegment struct) {
+        return struct.get(flags$LAYOUT, flags$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int flags;
+     * {@snippet lang=c :
+     * int flags
      * }
      */
-    public static void flags$set(MemorySegment seg, int x) {
-        constants$1.const$2.set(seg, x);
-    }
-    public static int flags$get(MemorySegment seg, long index) {
-        return (int)constants$1.const$2.get(seg.asSlice(index*sizeof()));
+    public static void flags(MemorySegment struct, int fieldValue) {
+        struct.set(flags$LAYOUT, flags$OFFSET, fieldValue);
     }
-    public static void flags$set(MemorySegment seg, long index, int x) {
-        constants$1.const$2.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfLong fh$LAYOUT = (OfLong)$LAYOUT.select(groupElement("fh"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * uint64_t fh
+     * }
+     */
+    public static final OfLong fh$layout() {
+        return fh$LAYOUT;
     }
-    public static VarHandle fh$VH() {
-        return constants$1.const$3;
+
+    private static final long fh$OFFSET = 16;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * uint64_t fh
+     * }
+     */
+    public static final long fh$offset() {
+        return fh$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned long fh;
+     * {@snippet lang=c :
+     * uint64_t fh
      * }
      */
-    public static long fh$get(MemorySegment seg) {
-        return (long)constants$1.const$3.get(seg);
+    public static long fh(MemorySegment struct) {
+        return struct.get(fh$LAYOUT, fh$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned long fh;
+     * {@snippet lang=c :
+     * uint64_t fh
      * }
      */
-    public static void fh$set(MemorySegment seg, long x) {
-        constants$1.const$3.set(seg, x);
-    }
-    public static long fh$get(MemorySegment seg, long index) {
-        return (long)constants$1.const$3.get(seg.asSlice(index*sizeof()));
+    public static void fh(MemorySegment struct, long fieldValue) {
+        struct.set(fh$LAYOUT, fh$OFFSET, fieldValue);
     }
-    public static void fh$set(MemorySegment seg, long index, long x) {
-        constants$1.const$3.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfLong lock_owner$LAYOUT = (OfLong)$LAYOUT.select(groupElement("lock_owner"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * uint64_t lock_owner
+     * }
+     */
+    public static final OfLong lock_owner$layout() {
+        return lock_owner$LAYOUT;
     }
-    public static VarHandle lock_owner$VH() {
-        return constants$1.const$4;
+
+    private static final long lock_owner$OFFSET = 24;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * uint64_t lock_owner
+     * }
+     */
+    public static final long lock_owner$offset() {
+        return lock_owner$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned long lock_owner;
+     * {@snippet lang=c :
+     * uint64_t lock_owner
      * }
      */
-    public static long lock_owner$get(MemorySegment seg) {
-        return (long)constants$1.const$4.get(seg);
+    public static long lock_owner(MemorySegment struct) {
+        return struct.get(lock_owner$LAYOUT, lock_owner$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned long lock_owner;
+     * {@snippet lang=c :
+     * uint64_t lock_owner
      * }
      */
-    public static void lock_owner$set(MemorySegment seg, long x) {
-        constants$1.const$4.set(seg, x);
-    }
-    public static long lock_owner$get(MemorySegment seg, long index) {
-        return (long)constants$1.const$4.get(seg.asSlice(index*sizeof()));
+    public static void lock_owner(MemorySegment struct, long fieldValue) {
+        struct.set(lock_owner$LAYOUT, lock_owner$OFFSET, fieldValue);
     }
-    public static void lock_owner$set(MemorySegment seg, long index, long x) {
-        constants$1.const$4.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt poll_events$LAYOUT = (OfInt)$LAYOUT.select(groupElement("poll_events"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * uint32_t poll_events
+     * }
+     */
+    public static final OfInt poll_events$layout() {
+        return poll_events$LAYOUT;
     }
-    public static VarHandle poll_events$VH() {
-        return constants$1.const$5;
+
+    private static final long poll_events$OFFSET = 32;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * uint32_t poll_events
+     * }
+     */
+    public static final long poll_events$offset() {
+        return poll_events$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned int poll_events;
+     * {@snippet lang=c :
+     * uint32_t poll_events
      * }
      */
-    public static int poll_events$get(MemorySegment seg) {
-        return (int)constants$1.const$5.get(seg);
+    public static int poll_events(MemorySegment struct) {
+        return struct.get(poll_events$LAYOUT, poll_events$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned int poll_events;
+     * {@snippet lang=c :
+     * uint32_t poll_events
      * }
      */
-    public static void poll_events$set(MemorySegment seg, int x) {
-        constants$1.const$5.set(seg, x);
+    public static void poll_events(MemorySegment struct, int fieldValue) {
+        struct.set(poll_events$LAYOUT, poll_events$OFFSET, fieldValue);
     }
-    public static int poll_events$get(MemorySegment seg, long index) {
-        return (int)constants$1.const$5.get(seg.asSlice(index*sizeof()));
+
+    /**
+     * Obtains a slice of {@code arrayParam} which selects the array element at {@code index}.
+     * The returned segment has address {@code arrayParam.address() + index * layout().byteSize()}
+     */
+    public static MemorySegment asSlice(MemorySegment array, long index) {
+        return array.asSlice(layout().byteSize() * index);
+    }
+
+    /**
+     * The size (in bytes) of this struct
+     */
+    public static long sizeof() { return layout().byteSize(); }
+
+    /**
+     * Allocate a segment of size {@code layout().byteSize()} using {@code allocator}
+     */
+    public static MemorySegment allocate(SegmentAllocator allocator) {
+        return allocator.allocate(layout());
+    }
+
+    /**
+     * Allocate an array of size {@code elementCount} using {@code allocator}.
+     * The returned segment has size {@code elementCount * layout().byteSize()}.
+     */
+    public static MemorySegment allocateArray(long elementCount, SegmentAllocator allocator) {
+        return allocator.allocate(MemoryLayout.sequenceLayout(elementCount, layout()));
     }
-    public static void poll_events$set(MemorySegment seg, long index, int x) {
-        constants$1.const$5.set(seg.asSlice(index*sizeof()), x);
+
+    /**
+     * Reinterprets {@code addr} using target {@code arena} and {@code cleanupAction) (if any).
+     * The returned segment has size {@code layout().byteSize()}
+     */
+    public static MemorySegment reinterpret(MemorySegment addr, Arena arena, Consumer<MemorySegment> cleanup) {
+        return reinterpret(addr, 1, arena, cleanup);
     }
-    public static long sizeof() { return $LAYOUT().byteSize(); }
-    public static MemorySegment allocate(SegmentAllocator allocator) { return allocator.allocate($LAYOUT()); }
-    public static MemorySegment allocateArray(long len, SegmentAllocator allocator) {
-        return allocator.allocate(MemoryLayout.sequenceLayout(len, $LAYOUT()));
+
+    /**
+     * Reinterprets {@code addr} using target {@code arena} and {@code cleanupAction) (if any).
+     * The returned segment has size {@code elementCount * layout().byteSize()}
+     */
+    public static MemorySegment reinterpret(MemorySegment addr, long elementCount, Arena arena, Consumer<MemorySegment> cleanup) {
+        return addr.reinterpret(layout().byteSize() * elementCount, arena, cleanup);
     }
-    public static MemorySegment ofAddress(MemorySegment addr, Arena scope) { return RuntimeHelper.asArray(addr, $LAYOUT(), 1, scope); }
 }
 
-
diff --git a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/fuse_fill_dir_t.java b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/fuse_fill_dir_t.java
index e836d2aa..c1a6cd23 100644
--- a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/fuse_fill_dir_t.java
+++ b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/fuse_fill_dir_t.java
@@ -2,32 +2,89 @@
 
 package org.cryptomator.jfuse.linux.amd64.extr.fuse3;
 
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
+import java.lang.invoke.*;
 import java.lang.foreign.*;
+import java.nio.ByteOrder;
+import java.util.*;
+import java.util.function.*;
+import java.util.stream.*;
+
 import static java.lang.foreign.ValueLayout.*;
+import static java.lang.foreign.MemoryLayout.PathElement.*;
+
 /**
- * {@snippet :
- * int (*fuse_fill_dir_t)(void* buf,char* name,struct stat* stbuf,long off,enum fuse_fill_dir_flags flags);
+ * {@snippet lang=c :
+ * typedef int (*fuse_fill_dir_t)(void *, const char *, const struct stat {
+ *     __dev_t st_dev;
+ *     __ino_t st_ino;
+ *     __nlink_t st_nlink;
+ *     __mode_t st_mode;
+ *     __uid_t st_uid;
+ *     __gid_t st_gid;
+ *     int __pad0;
+ *     __dev_t st_rdev;
+ *     __off_t st_size;
+ *     __blksize_t st_blksize;
+ *     __blkcnt_t st_blocks;
+ *     struct timespec st_atim;
+ *     struct timespec st_mtim;
+ *     struct timespec st_ctim;
+ *     __syscall_slong_t __glibc_reserved[3];
+ * } *, off_t, enum fuse_fill_dir_flags {
+ *     FUSE_FILL_DIR_PLUS = (1 << 1)
+ * })
  * }
  */
-public interface fuse_fill_dir_t {
+public class fuse_fill_dir_t {
 
-    int apply(java.lang.foreign.MemorySegment buf, java.lang.foreign.MemorySegment name, java.lang.foreign.MemorySegment stbuf, long off, int flags);
-    static MemorySegment allocate(fuse_fill_dir_t fi, Arena scope) {
-        return RuntimeHelper.upcallStub(constants$10.const$0, fi, constants$9.const$5, scope);
+    fuse_fill_dir_t() {
+        // Should not be called directly
     }
-    static fuse_fill_dir_t ofAddress(MemorySegment addr, Arena arena) {
-        MemorySegment symbol = addr.reinterpret(arena, null);
-        return (java.lang.foreign.MemorySegment _buf, java.lang.foreign.MemorySegment _name, java.lang.foreign.MemorySegment _stbuf, long _off, int _flags) -> {
-            try {
-                return (int)constants$10.const$1.invokeExact(symbol, _buf, _name, _stbuf, _off, _flags);
-            } catch (Throwable ex$) {
-                throw new AssertionError("should not reach here", ex$);
-            }
-        };
+
+    /**
+     * The function pointer signature, expressed as a functional interface
+     */
+    public interface Function {
+        int apply(MemorySegment buf, MemorySegment name, MemorySegment stbuf, long off, int flags);
     }
-}
 
+    private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+        fuse_h.C_INT,
+        fuse_h.C_POINTER,
+        fuse_h.C_POINTER,
+        fuse_h.C_POINTER,
+        fuse_h.C_LONG,
+        fuse_h.C_INT
+    );
+
+    /**
+     * The descriptor of this function pointer
+     */
+    public static FunctionDescriptor descriptor() {
+        return $DESC;
+    }
+
+    private static final MethodHandle UP$MH = fuse_h.upcallHandle(fuse_fill_dir_t.Function.class, "apply", $DESC);
+
+    /**
+     * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+     * The lifetime of the returned segment is managed by {@code arena}
+     */
+    public static MemorySegment allocate(fuse_fill_dir_t.Function fi, Arena arena) {
+        return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+    }
+
+    private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+    /**
+     * Invoke the upcall stub {@code funcPtr}, with given parameters
+     */
+    public static int invoke(MemorySegment funcPtr,MemorySegment buf, MemorySegment name, MemorySegment stbuf, long off, int flags) {
+        try {
+            return (int) DOWN$MH.invokeExact(funcPtr, buf, name, stbuf, off, flags);
+        } catch (Throwable ex$) {
+            throw new AssertionError("should not reach here", ex$);
+        }
+    }
+}
 
diff --git a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/fuse_h.java b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/fuse_h.java
index 00882bba..de158683 100644
--- a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/fuse_h.java
+++ b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/fuse_h.java
@@ -2,245 +2,725 @@
 
 package org.cryptomator.jfuse.linux.amd64.extr.fuse3;
 
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
+import java.lang.invoke.*;
 import java.lang.foreign.*;
+import java.nio.ByteOrder;
+import java.util.*;
+import java.util.function.*;
+import java.util.stream.*;
+
 import static java.lang.foreign.ValueLayout.*;
-public class fuse_h  {
+import static java.lang.foreign.MemoryLayout.PathElement.*;
+
+public class fuse_h {
+
+    fuse_h() {
+        // Should not be called directly
+    }
+
+    static final Arena LIBRARY_ARENA = Arena.ofAuto();
+    static final boolean TRACE_DOWNCALLS = Boolean.getBoolean("jextract.trace.downcalls");
+
+    static void traceDowncall(String name, Object... args) {
+         String traceArgs = Arrays.stream(args)
+                       .map(Object::toString)
+                       .collect(Collectors.joining(", "));
+         System.out.printf("%s(%s)\n", name, traceArgs);
+    }
+
+    static MemorySegment findOrThrow(String symbol) {
+        return SYMBOL_LOOKUP.find(symbol)
+            .orElseThrow(() -> new UnsatisfiedLinkError("unresolved symbol: " + symbol));
+    }
+
+    static MethodHandle upcallHandle(Class<?> fi, String name, FunctionDescriptor fdesc) {
+        try {
+            return MethodHandles.lookup().findVirtual(fi, name, fdesc.toMethodType());
+        } catch (ReflectiveOperationException ex) {
+            throw new AssertionError(ex);
+        }
+    }
+
+    static MemoryLayout align(MemoryLayout layout, long align) {
+        return switch (layout) {
+            case PaddingLayout p -> p;
+            case ValueLayout v -> v.withByteAlignment(align);
+            case GroupLayout g -> {
+                MemoryLayout[] alignedMembers = g.memberLayouts().stream()
+                        .map(m -> align(m, align)).toArray(MemoryLayout[]::new);
+                yield g instanceof StructLayout ?
+                        MemoryLayout.structLayout(alignedMembers) : MemoryLayout.unionLayout(alignedMembers);
+            }
+            case SequenceLayout s -> MemoryLayout.sequenceLayout(s.elementCount(), align(s.elementLayout(), align));
+        };
+    }
+
+    static final SymbolLookup SYMBOL_LOOKUP = SymbolLookup.loaderLookup()
+            .or(Linker.nativeLinker().defaultLookup());
 
-    public static final OfByte C_CHAR = JAVA_BYTE;
-    public static final OfShort C_SHORT = JAVA_SHORT;
-    public static final OfInt C_INT = JAVA_INT;
-    public static final OfLong C_LONG = JAVA_LONG;
-    public static final OfLong C_LONG_LONG = JAVA_LONG;
-    public static final OfFloat C_FLOAT = JAVA_FLOAT;
-    public static final OfDouble C_DOUBLE = JAVA_DOUBLE;
-    public static final AddressLayout C_POINTER = RuntimeHelper.POINTER;
-    public static MethodHandle fuse_version$MH() {
-        return RuntimeHelper.requireNonNull(constants$4.const$3,"fuse_version");
+    public static final ValueLayout.OfBoolean C_BOOL = ValueLayout.JAVA_BOOLEAN;
+    public static final ValueLayout.OfByte C_CHAR = ValueLayout.JAVA_BYTE;
+    public static final ValueLayout.OfShort C_SHORT = ValueLayout.JAVA_SHORT;
+    public static final ValueLayout.OfInt C_INT = ValueLayout.JAVA_INT;
+    public static final ValueLayout.OfLong C_LONG_LONG = ValueLayout.JAVA_LONG;
+    public static final ValueLayout.OfFloat C_FLOAT = ValueLayout.JAVA_FLOAT;
+    public static final ValueLayout.OfDouble C_DOUBLE = ValueLayout.JAVA_DOUBLE;
+    public static final AddressLayout C_POINTER = ValueLayout.ADDRESS
+            .withTargetLayout(MemoryLayout.sequenceLayout(java.lang.Long.MAX_VALUE, JAVA_BYTE));
+    public static final ValueLayout.OfLong C_LONG = ValueLayout.JAVA_LONG;
+
+    private static class fuse_version {
+        public static final FunctionDescriptor DESC = FunctionDescriptor.of(
+            fuse_h.C_INT    );
+
+        public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(
+                    fuse_h.findOrThrow("fuse_version"),
+                    DESC);
     }
+
     /**
-     * {@snippet :
-     * int fuse_version();
+     * Function descriptor for:
+     * {@snippet lang=c :
+     * int fuse_version()
+     * }
+     */
+    public static FunctionDescriptor fuse_version$descriptor() {
+        return fuse_version.DESC;
+    }
+
+    /**
+     * Downcall method handle for:
+     * {@snippet lang=c :
+     * int fuse_version()
+     * }
+     */
+    public static MethodHandle fuse_version$handle() {
+        return fuse_version.HANDLE;
+    }
+    /**
+     * {@snippet lang=c :
+     * int fuse_version()
      * }
      */
     public static int fuse_version() {
-        var mh$ = fuse_version$MH();
+        var mh$ = fuse_version.HANDLE;
         try {
+            if (TRACE_DOWNCALLS) {
+                traceDowncall("fuse_version");
+            }
             return (int)mh$.invokeExact();
         } catch (Throwable ex$) {
-            throw new AssertionError("should not reach here", ex$);
+           throw new AssertionError("should not reach here", ex$);
         }
     }
-    public static MethodHandle fuse_loop_cfg_create$MH() {
-        return RuntimeHelper.requireNonNull(constants$4.const$5,"fuse_loop_cfg_create");
+
+    private static class fuse_loop_cfg_create {
+        public static final FunctionDescriptor DESC = FunctionDescriptor.of(
+            fuse_h.C_POINTER    );
+
+        public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(
+                    fuse_h.findOrThrow("fuse_loop_cfg_create"),
+                    DESC);
     }
+
     /**
-     * {@snippet :
-     * struct fuse_loop_config* fuse_loop_cfg_create();
+     * Function descriptor for:
+     * {@snippet lang=c :
+     * struct fuse_loop_config *fuse_loop_cfg_create()
+     * }
+     */
+    public static FunctionDescriptor fuse_loop_cfg_create$descriptor() {
+        return fuse_loop_cfg_create.DESC;
+    }
+
+    /**
+     * Downcall method handle for:
+     * {@snippet lang=c :
+     * struct fuse_loop_config *fuse_loop_cfg_create()
+     * }
+     */
+    public static MethodHandle fuse_loop_cfg_create$handle() {
+        return fuse_loop_cfg_create.HANDLE;
+    }
+    /**
+     * {@snippet lang=c :
+     * struct fuse_loop_config *fuse_loop_cfg_create()
      * }
      */
     public static MemorySegment fuse_loop_cfg_create() {
-        var mh$ = fuse_loop_cfg_create$MH();
+        var mh$ = fuse_loop_cfg_create.HANDLE;
         try {
-            return (java.lang.foreign.MemorySegment)mh$.invokeExact();
+            if (TRACE_DOWNCALLS) {
+                traceDowncall("fuse_loop_cfg_create");
+            }
+            return (MemorySegment)mh$.invokeExact();
         } catch (Throwable ex$) {
-            throw new AssertionError("should not reach here", ex$);
+           throw new AssertionError("should not reach here", ex$);
         }
     }
-    public static MethodHandle fuse_loop_cfg_destroy$MH() {
-        return RuntimeHelper.requireNonNull(constants$5.const$1,"fuse_loop_cfg_destroy");
+
+    private static class fuse_loop_cfg_destroy {
+        public static final FunctionDescriptor DESC = FunctionDescriptor.ofVoid(
+            fuse_h.C_POINTER
+        );
+
+        public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(
+                    fuse_h.findOrThrow("fuse_loop_cfg_destroy"),
+                    DESC);
+    }
+
+    /**
+     * Function descriptor for:
+     * {@snippet lang=c :
+     * void fuse_loop_cfg_destroy(struct fuse_loop_config *config)
+     * }
+     */
+    public static FunctionDescriptor fuse_loop_cfg_destroy$descriptor() {
+        return fuse_loop_cfg_destroy.DESC;
+    }
+
+    /**
+     * Downcall method handle for:
+     * {@snippet lang=c :
+     * void fuse_loop_cfg_destroy(struct fuse_loop_config *config)
+     * }
+     */
+    public static MethodHandle fuse_loop_cfg_destroy$handle() {
+        return fuse_loop_cfg_destroy.HANDLE;
     }
     /**
-     * {@snippet :
-     * void fuse_loop_cfg_destroy(struct fuse_loop_config* config);
+     * {@snippet lang=c :
+     * void fuse_loop_cfg_destroy(struct fuse_loop_config *config)
      * }
      */
     public static void fuse_loop_cfg_destroy(MemorySegment config) {
-        var mh$ = fuse_loop_cfg_destroy$MH();
+        var mh$ = fuse_loop_cfg_destroy.HANDLE;
         try {
+            if (TRACE_DOWNCALLS) {
+                traceDowncall("fuse_loop_cfg_destroy", config);
+            }
             mh$.invokeExact(config);
         } catch (Throwable ex$) {
-            throw new AssertionError("should not reach here", ex$);
+           throw new AssertionError("should not reach here", ex$);
         }
     }
-    public static MethodHandle fuse_loop_cfg_set_max_threads$MH() {
-        return RuntimeHelper.requireNonNull(constants$5.const$3,"fuse_loop_cfg_set_max_threads");
+
+    private static class fuse_loop_cfg_set_max_threads {
+        public static final FunctionDescriptor DESC = FunctionDescriptor.ofVoid(
+            fuse_h.C_POINTER,
+            fuse_h.C_INT
+        );
+
+        public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(
+                    fuse_h.findOrThrow("fuse_loop_cfg_set_max_threads"),
+                    DESC);
+    }
+
+    /**
+     * Function descriptor for:
+     * {@snippet lang=c :
+     * void fuse_loop_cfg_set_max_threads(struct fuse_loop_config *config, unsigned int value)
+     * }
+     */
+    public static FunctionDescriptor fuse_loop_cfg_set_max_threads$descriptor() {
+        return fuse_loop_cfg_set_max_threads.DESC;
+    }
+
+    /**
+     * Downcall method handle for:
+     * {@snippet lang=c :
+     * void fuse_loop_cfg_set_max_threads(struct fuse_loop_config *config, unsigned int value)
+     * }
+     */
+    public static MethodHandle fuse_loop_cfg_set_max_threads$handle() {
+        return fuse_loop_cfg_set_max_threads.HANDLE;
     }
     /**
-     * {@snippet :
-     * void fuse_loop_cfg_set_max_threads(struct fuse_loop_config* config, unsigned int value);
+     * {@snippet lang=c :
+     * void fuse_loop_cfg_set_max_threads(struct fuse_loop_config *config, unsigned int value)
      * }
      */
     public static void fuse_loop_cfg_set_max_threads(MemorySegment config, int value) {
-        var mh$ = fuse_loop_cfg_set_max_threads$MH();
+        var mh$ = fuse_loop_cfg_set_max_threads.HANDLE;
         try {
+            if (TRACE_DOWNCALLS) {
+                traceDowncall("fuse_loop_cfg_set_max_threads", config, value);
+            }
             mh$.invokeExact(config, value);
         } catch (Throwable ex$) {
-            throw new AssertionError("should not reach here", ex$);
+           throw new AssertionError("should not reach here", ex$);
         }
     }
-    public static MethodHandle fuse_loop_cfg_set_clone_fd$MH() {
-        return RuntimeHelper.requireNonNull(constants$5.const$4,"fuse_loop_cfg_set_clone_fd");
+
+    private static class fuse_loop_cfg_set_clone_fd {
+        public static final FunctionDescriptor DESC = FunctionDescriptor.ofVoid(
+            fuse_h.C_POINTER,
+            fuse_h.C_INT
+        );
+
+        public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(
+                    fuse_h.findOrThrow("fuse_loop_cfg_set_clone_fd"),
+                    DESC);
     }
+
     /**
-     * {@snippet :
-     * void fuse_loop_cfg_set_clone_fd(struct fuse_loop_config* config, unsigned int value);
+     * Function descriptor for:
+     * {@snippet lang=c :
+     * void fuse_loop_cfg_set_clone_fd(struct fuse_loop_config *config, unsigned int value)
+     * }
+     */
+    public static FunctionDescriptor fuse_loop_cfg_set_clone_fd$descriptor() {
+        return fuse_loop_cfg_set_clone_fd.DESC;
+    }
+
+    /**
+     * Downcall method handle for:
+     * {@snippet lang=c :
+     * void fuse_loop_cfg_set_clone_fd(struct fuse_loop_config *config, unsigned int value)
+     * }
+     */
+    public static MethodHandle fuse_loop_cfg_set_clone_fd$handle() {
+        return fuse_loop_cfg_set_clone_fd.HANDLE;
+    }
+    /**
+     * {@snippet lang=c :
+     * void fuse_loop_cfg_set_clone_fd(struct fuse_loop_config *config, unsigned int value)
      * }
      */
     public static void fuse_loop_cfg_set_clone_fd(MemorySegment config, int value) {
-        var mh$ = fuse_loop_cfg_set_clone_fd$MH();
+        var mh$ = fuse_loop_cfg_set_clone_fd.HANDLE;
         try {
+            if (TRACE_DOWNCALLS) {
+                traceDowncall("fuse_loop_cfg_set_clone_fd", config, value);
+            }
             mh$.invokeExact(config, value);
         } catch (Throwable ex$) {
-            throw new AssertionError("should not reach here", ex$);
+           throw new AssertionError("should not reach here", ex$);
         }
     }
-    public static MethodHandle fuse_lib_help$MH() {
-        return RuntimeHelper.requireNonNull(constants$36.const$0,"fuse_lib_help");
+
+    private static class fuse_lib_help {
+        public static final FunctionDescriptor DESC = FunctionDescriptor.ofVoid(
+            fuse_h.C_POINTER
+        );
+
+        public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(
+                    fuse_h.findOrThrow("fuse_lib_help"),
+                    DESC);
     }
+
     /**
-     * {@snippet :
-     * void fuse_lib_help(struct fuse_args* args);
+     * Function descriptor for:
+     * {@snippet lang=c :
+     * void fuse_lib_help(struct fuse_args *args)
+     * }
+     */
+    public static FunctionDescriptor fuse_lib_help$descriptor() {
+        return fuse_lib_help.DESC;
+    }
+
+    /**
+     * Downcall method handle for:
+     * {@snippet lang=c :
+     * void fuse_lib_help(struct fuse_args *args)
+     * }
+     */
+    public static MethodHandle fuse_lib_help$handle() {
+        return fuse_lib_help.HANDLE;
+    }
+    /**
+     * {@snippet lang=c :
+     * void fuse_lib_help(struct fuse_args *args)
      * }
      */
     public static void fuse_lib_help(MemorySegment args) {
-        var mh$ = fuse_lib_help$MH();
+        var mh$ = fuse_lib_help.HANDLE;
         try {
+            if (TRACE_DOWNCALLS) {
+                traceDowncall("fuse_lib_help", args);
+            }
             mh$.invokeExact(args);
         } catch (Throwable ex$) {
-            throw new AssertionError("should not reach here", ex$);
+           throw new AssertionError("should not reach here", ex$);
         }
     }
-    public static MethodHandle fuse_new$MH() {
-        return RuntimeHelper.requireNonNull(constants$36.const$2,"fuse_new");
+
+    private static class fuse_new {
+        public static final FunctionDescriptor DESC = FunctionDescriptor.of(
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER,
+            fuse_h.C_LONG,
+            fuse_h.C_POINTER
+        );
+
+        public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(
+                    fuse_h.findOrThrow("fuse_new"),
+                    DESC);
     }
+
     /**
-     * {@snippet :
-     * struct fuse* fuse_new(struct fuse_args* args, struct fuse_operations* op, unsigned long op_size, void* private_data);
+     * Function descriptor for:
+     * {@snippet lang=c :
+     * struct fuse *fuse_new(struct fuse_args *args, const struct fuse_operations *op, size_t op_size, void *private_data)
+     * }
+     */
+    public static FunctionDescriptor fuse_new$descriptor() {
+        return fuse_new.DESC;
+    }
+
+    /**
+     * Downcall method handle for:
+     * {@snippet lang=c :
+     * struct fuse *fuse_new(struct fuse_args *args, const struct fuse_operations *op, size_t op_size, void *private_data)
+     * }
+     */
+    public static MethodHandle fuse_new$handle() {
+        return fuse_new.HANDLE;
+    }
+    /**
+     * {@snippet lang=c :
+     * struct fuse *fuse_new(struct fuse_args *args, const struct fuse_operations *op, size_t op_size, void *private_data)
      * }
      */
     public static MemorySegment fuse_new(MemorySegment args, MemorySegment op, long op_size, MemorySegment private_data) {
-        var mh$ = fuse_new$MH();
+        var mh$ = fuse_new.HANDLE;
         try {
-            return (java.lang.foreign.MemorySegment)mh$.invokeExact(args, op, op_size, private_data);
+            if (TRACE_DOWNCALLS) {
+                traceDowncall("fuse_new", args, op, op_size, private_data);
+            }
+            return (MemorySegment)mh$.invokeExact(args, op, op_size, private_data);
         } catch (Throwable ex$) {
-            throw new AssertionError("should not reach here", ex$);
+           throw new AssertionError("should not reach here", ex$);
         }
     }
-    public static MethodHandle fuse_mount$MH() {
-        return RuntimeHelper.requireNonNull(constants$36.const$3,"fuse_mount");
+
+    private static class fuse_mount {
+        public static final FunctionDescriptor DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER
+        );
+
+        public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(
+                    fuse_h.findOrThrow("fuse_mount"),
+                    DESC);
+    }
+
+    /**
+     * Function descriptor for:
+     * {@snippet lang=c :
+     * int fuse_mount(struct fuse *f, const char *mountpoint)
+     * }
+     */
+    public static FunctionDescriptor fuse_mount$descriptor() {
+        return fuse_mount.DESC;
+    }
+
+    /**
+     * Downcall method handle for:
+     * {@snippet lang=c :
+     * int fuse_mount(struct fuse *f, const char *mountpoint)
+     * }
+     */
+    public static MethodHandle fuse_mount$handle() {
+        return fuse_mount.HANDLE;
     }
     /**
-     * {@snippet :
-     * int fuse_mount(struct fuse* f, char* mountpoint);
+     * {@snippet lang=c :
+     * int fuse_mount(struct fuse *f, const char *mountpoint)
      * }
      */
     public static int fuse_mount(MemorySegment f, MemorySegment mountpoint) {
-        var mh$ = fuse_mount$MH();
+        var mh$ = fuse_mount.HANDLE;
         try {
+            if (TRACE_DOWNCALLS) {
+                traceDowncall("fuse_mount", f, mountpoint);
+            }
             return (int)mh$.invokeExact(f, mountpoint);
         } catch (Throwable ex$) {
-            throw new AssertionError("should not reach here", ex$);
+           throw new AssertionError("should not reach here", ex$);
         }
     }
-    public static MethodHandle fuse_unmount$MH() {
-        return RuntimeHelper.requireNonNull(constants$36.const$4,"fuse_unmount");
+
+    private static class fuse_unmount {
+        public static final FunctionDescriptor DESC = FunctionDescriptor.ofVoid(
+            fuse_h.C_POINTER
+        );
+
+        public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(
+                    fuse_h.findOrThrow("fuse_unmount"),
+                    DESC);
     }
+
     /**
-     * {@snippet :
-     * void fuse_unmount(struct fuse* f);
+     * Function descriptor for:
+     * {@snippet lang=c :
+     * void fuse_unmount(struct fuse *f)
+     * }
+     */
+    public static FunctionDescriptor fuse_unmount$descriptor() {
+        return fuse_unmount.DESC;
+    }
+
+    /**
+     * Downcall method handle for:
+     * {@snippet lang=c :
+     * void fuse_unmount(struct fuse *f)
+     * }
+     */
+    public static MethodHandle fuse_unmount$handle() {
+        return fuse_unmount.HANDLE;
+    }
+    /**
+     * {@snippet lang=c :
+     * void fuse_unmount(struct fuse *f)
      * }
      */
     public static void fuse_unmount(MemorySegment f) {
-        var mh$ = fuse_unmount$MH();
+        var mh$ = fuse_unmount.HANDLE;
         try {
+            if (TRACE_DOWNCALLS) {
+                traceDowncall("fuse_unmount", f);
+            }
             mh$.invokeExact(f);
         } catch (Throwable ex$) {
-            throw new AssertionError("should not reach here", ex$);
+           throw new AssertionError("should not reach here", ex$);
         }
     }
-    public static MethodHandle fuse_destroy$MH() {
-        return RuntimeHelper.requireNonNull(constants$36.const$5,"fuse_destroy");
+
+    private static class fuse_destroy {
+        public static final FunctionDescriptor DESC = FunctionDescriptor.ofVoid(
+            fuse_h.C_POINTER
+        );
+
+        public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(
+                    fuse_h.findOrThrow("fuse_destroy"),
+                    DESC);
     }
+
     /**
-     * {@snippet :
-     * void fuse_destroy(struct fuse* f);
+     * Function descriptor for:
+     * {@snippet lang=c :
+     * void fuse_destroy(struct fuse *f)
+     * }
+     */
+    public static FunctionDescriptor fuse_destroy$descriptor() {
+        return fuse_destroy.DESC;
+    }
+
+    /**
+     * Downcall method handle for:
+     * {@snippet lang=c :
+     * void fuse_destroy(struct fuse *f)
+     * }
+     */
+    public static MethodHandle fuse_destroy$handle() {
+        return fuse_destroy.HANDLE;
+    }
+    /**
+     * {@snippet lang=c :
+     * void fuse_destroy(struct fuse *f)
      * }
      */
     public static void fuse_destroy(MemorySegment f) {
-        var mh$ = fuse_destroy$MH();
+        var mh$ = fuse_destroy.HANDLE;
         try {
+            if (TRACE_DOWNCALLS) {
+                traceDowncall("fuse_destroy", f);
+            }
             mh$.invokeExact(f);
         } catch (Throwable ex$) {
-            throw new AssertionError("should not reach here", ex$);
+           throw new AssertionError("should not reach here", ex$);
         }
     }
-    public static MethodHandle fuse_loop$MH() {
-        return RuntimeHelper.requireNonNull(constants$37.const$0,"fuse_loop");
+
+    private static class fuse_loop {
+        public static final FunctionDescriptor DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER
+        );
+
+        public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(
+                    fuse_h.findOrThrow("fuse_loop"),
+                    DESC);
     }
+
     /**
-     * {@snippet :
-     * int fuse_loop(struct fuse* f);
+     * Function descriptor for:
+     * {@snippet lang=c :
+     * int fuse_loop(struct fuse *f)
+     * }
+     */
+    public static FunctionDescriptor fuse_loop$descriptor() {
+        return fuse_loop.DESC;
+    }
+
+    /**
+     * Downcall method handle for:
+     * {@snippet lang=c :
+     * int fuse_loop(struct fuse *f)
+     * }
+     */
+    public static MethodHandle fuse_loop$handle() {
+        return fuse_loop.HANDLE;
+    }
+    /**
+     * {@snippet lang=c :
+     * int fuse_loop(struct fuse *f)
      * }
      */
     public static int fuse_loop(MemorySegment f) {
-        var mh$ = fuse_loop$MH();
+        var mh$ = fuse_loop.HANDLE;
         try {
+            if (TRACE_DOWNCALLS) {
+                traceDowncall("fuse_loop", f);
+            }
             return (int)mh$.invokeExact(f);
         } catch (Throwable ex$) {
-            throw new AssertionError("should not reach here", ex$);
+           throw new AssertionError("should not reach here", ex$);
         }
     }
-    public static MethodHandle fuse_exit$MH() {
-        return RuntimeHelper.requireNonNull(constants$37.const$1,"fuse_exit");
+
+    private static class fuse_exit {
+        public static final FunctionDescriptor DESC = FunctionDescriptor.ofVoid(
+            fuse_h.C_POINTER
+        );
+
+        public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(
+                    fuse_h.findOrThrow("fuse_exit"),
+                    DESC);
     }
+
     /**
-     * {@snippet :
-     * void fuse_exit(struct fuse* f);
+     * Function descriptor for:
+     * {@snippet lang=c :
+     * void fuse_exit(struct fuse *f)
+     * }
+     */
+    public static FunctionDescriptor fuse_exit$descriptor() {
+        return fuse_exit.DESC;
+    }
+
+    /**
+     * Downcall method handle for:
+     * {@snippet lang=c :
+     * void fuse_exit(struct fuse *f)
+     * }
+     */
+    public static MethodHandle fuse_exit$handle() {
+        return fuse_exit.HANDLE;
+    }
+    /**
+     * {@snippet lang=c :
+     * void fuse_exit(struct fuse *f)
      * }
      */
     public static void fuse_exit(MemorySegment f) {
-        var mh$ = fuse_exit$MH();
+        var mh$ = fuse_exit.HANDLE;
         try {
+            if (TRACE_DOWNCALLS) {
+                traceDowncall("fuse_exit", f);
+            }
             mh$.invokeExact(f);
         } catch (Throwable ex$) {
-            throw new AssertionError("should not reach here", ex$);
+           throw new AssertionError("should not reach here", ex$);
         }
     }
-    public static MethodHandle fuse_loop_mt$MH() {
-        return RuntimeHelper.requireNonNull(constants$37.const$2,"fuse_loop_mt");
+
+    private static class fuse_loop_mt {
+        public static final FunctionDescriptor DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER
+        );
+
+        public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(
+                    fuse_h.findOrThrow("fuse_loop_mt"),
+                    DESC);
+    }
+
+    /**
+     * Function descriptor for:
+     * {@snippet lang=c :
+     * int fuse_loop_mt(struct fuse *f, struct fuse_loop_config *config)
+     * }
+     */
+    public static FunctionDescriptor fuse_loop_mt$descriptor() {
+        return fuse_loop_mt.DESC;
+    }
+
+    /**
+     * Downcall method handle for:
+     * {@snippet lang=c :
+     * int fuse_loop_mt(struct fuse *f, struct fuse_loop_config *config)
+     * }
+     */
+    public static MethodHandle fuse_loop_mt$handle() {
+        return fuse_loop_mt.HANDLE;
     }
     /**
-     * {@snippet :
-     * int fuse_loop_mt(struct fuse* f, struct fuse_loop_config* config);
+     * {@snippet lang=c :
+     * int fuse_loop_mt(struct fuse *f, struct fuse_loop_config *config)
      * }
      */
     public static int fuse_loop_mt(MemorySegment f, MemorySegment config) {
-        var mh$ = fuse_loop_mt$MH();
+        var mh$ = fuse_loop_mt.HANDLE;
         try {
+            if (TRACE_DOWNCALLS) {
+                traceDowncall("fuse_loop_mt", f, config);
+            }
             return (int)mh$.invokeExact(f, config);
         } catch (Throwable ex$) {
-            throw new AssertionError("should not reach here", ex$);
+           throw new AssertionError("should not reach here", ex$);
         }
     }
-    public static MethodHandle fuse_get_session$MH() {
-        return RuntimeHelper.requireNonNull(constants$37.const$4,"fuse_get_session");
+
+    private static class fuse_get_session {
+        public static final FunctionDescriptor DESC = FunctionDescriptor.of(
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER
+        );
+
+        public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(
+                    fuse_h.findOrThrow("fuse_get_session"),
+                    DESC);
     }
+
+    /**
+     * Function descriptor for:
+     * {@snippet lang=c :
+     * struct fuse_session *fuse_get_session(struct fuse *f)
+     * }
+     */
+    public static FunctionDescriptor fuse_get_session$descriptor() {
+        return fuse_get_session.DESC;
+    }
+
     /**
-     * {@snippet :
-     * struct fuse_session* fuse_get_session(struct fuse* f);
+     * Downcall method handle for:
+     * {@snippet lang=c :
+     * struct fuse_session *fuse_get_session(struct fuse *f)
+     * }
+     */
+    public static MethodHandle fuse_get_session$handle() {
+        return fuse_get_session.HANDLE;
+    }
+    /**
+     * {@snippet lang=c :
+     * struct fuse_session *fuse_get_session(struct fuse *f)
      * }
      */
     public static MemorySegment fuse_get_session(MemorySegment f) {
-        var mh$ = fuse_get_session$MH();
+        var mh$ = fuse_get_session.HANDLE;
         try {
-            return (java.lang.foreign.MemorySegment)mh$.invokeExact(f);
+            if (TRACE_DOWNCALLS) {
+                traceDowncall("fuse_get_session", f);
+            }
+            return (MemorySegment)mh$.invokeExact(f);
         } catch (Throwable ex$) {
-            throw new AssertionError("should not reach here", ex$);
+           throw new AssertionError("should not reach here", ex$);
         }
     }
 }
 
-
diff --git a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/fuse_loop_config_v1.java b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/fuse_loop_config_v1.java
index d67ec659..f6a82f9d 100644
--- a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/fuse_loop_config_v1.java
+++ b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/fuse_loop_config_v1.java
@@ -2,84 +2,172 @@
 
 package org.cryptomator.jfuse.linux.amd64.extr.fuse3;
 
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
+import java.lang.invoke.*;
 import java.lang.foreign.*;
+import java.nio.ByteOrder;
+import java.util.*;
+import java.util.function.*;
+import java.util.stream.*;
+
 import static java.lang.foreign.ValueLayout.*;
+import static java.lang.foreign.MemoryLayout.PathElement.*;
+
 /**
- * {@snippet :
+ * {@snippet lang=c :
  * struct fuse_loop_config_v1 {
  *     int clone_fd;
  *     unsigned int max_idle_threads;
- * };
+ * }
  * }
  */
 public class fuse_loop_config_v1 {
 
-    public static MemoryLayout $LAYOUT() {
-        return constants$2.const$0;
+    fuse_loop_config_v1() {
+        // Should not be called directly
     }
-    public static VarHandle clone_fd$VH() {
-        return constants$2.const$1;
+
+    private static final GroupLayout $LAYOUT = MemoryLayout.structLayout(
+        fuse_h.C_INT.withName("clone_fd"),
+        fuse_h.C_INT.withName("max_idle_threads")
+    ).withName("fuse_loop_config_v1");
+
+    /**
+     * The layout of this struct
+     */
+    public static final GroupLayout layout() {
+        return $LAYOUT;
     }
+
+    private static final OfInt clone_fd$LAYOUT = (OfInt)$LAYOUT.select(groupElement("clone_fd"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int clone_fd
+     * }
+     */
+    public static final OfInt clone_fd$layout() {
+        return clone_fd$LAYOUT;
+    }
+
+    private static final long clone_fd$OFFSET = 0;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int clone_fd
+     * }
+     */
+    public static final long clone_fd$offset() {
+        return clone_fd$OFFSET;
+    }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int clone_fd;
+     * {@snippet lang=c :
+     * int clone_fd
      * }
      */
-    public static int clone_fd$get(MemorySegment seg) {
-        return (int)constants$2.const$1.get(seg);
+    public static int clone_fd(MemorySegment struct) {
+        return struct.get(clone_fd$LAYOUT, clone_fd$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int clone_fd;
+     * {@snippet lang=c :
+     * int clone_fd
      * }
      */
-    public static void clone_fd$set(MemorySegment seg, int x) {
-        constants$2.const$1.set(seg, x);
-    }
-    public static int clone_fd$get(MemorySegment seg, long index) {
-        return (int)constants$2.const$1.get(seg.asSlice(index*sizeof()));
+    public static void clone_fd(MemorySegment struct, int fieldValue) {
+        struct.set(clone_fd$LAYOUT, clone_fd$OFFSET, fieldValue);
     }
-    public static void clone_fd$set(MemorySegment seg, long index, int x) {
-        constants$2.const$1.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt max_idle_threads$LAYOUT = (OfInt)$LAYOUT.select(groupElement("max_idle_threads"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * unsigned int max_idle_threads
+     * }
+     */
+    public static final OfInt max_idle_threads$layout() {
+        return max_idle_threads$LAYOUT;
     }
-    public static VarHandle max_idle_threads$VH() {
-        return constants$2.const$2;
+
+    private static final long max_idle_threads$OFFSET = 4;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * unsigned int max_idle_threads
+     * }
+     */
+    public static final long max_idle_threads$offset() {
+        return max_idle_threads$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned int max_idle_threads;
+     * {@snippet lang=c :
+     * unsigned int max_idle_threads
      * }
      */
-    public static int max_idle_threads$get(MemorySegment seg) {
-        return (int)constants$2.const$2.get(seg);
+    public static int max_idle_threads(MemorySegment struct) {
+        return struct.get(max_idle_threads$LAYOUT, max_idle_threads$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned int max_idle_threads;
+     * {@snippet lang=c :
+     * unsigned int max_idle_threads
      * }
      */
-    public static void max_idle_threads$set(MemorySegment seg, int x) {
-        constants$2.const$2.set(seg, x);
+    public static void max_idle_threads(MemorySegment struct, int fieldValue) {
+        struct.set(max_idle_threads$LAYOUT, max_idle_threads$OFFSET, fieldValue);
+    }
+
+    /**
+     * Obtains a slice of {@code arrayParam} which selects the array element at {@code index}.
+     * The returned segment has address {@code arrayParam.address() + index * layout().byteSize()}
+     */
+    public static MemorySegment asSlice(MemorySegment array, long index) {
+        return array.asSlice(layout().byteSize() * index);
+    }
+
+    /**
+     * The size (in bytes) of this struct
+     */
+    public static long sizeof() { return layout().byteSize(); }
+
+    /**
+     * Allocate a segment of size {@code layout().byteSize()} using {@code allocator}
+     */
+    public static MemorySegment allocate(SegmentAllocator allocator) {
+        return allocator.allocate(layout());
     }
-    public static int max_idle_threads$get(MemorySegment seg, long index) {
-        return (int)constants$2.const$2.get(seg.asSlice(index*sizeof()));
+
+    /**
+     * Allocate an array of size {@code elementCount} using {@code allocator}.
+     * The returned segment has size {@code elementCount * layout().byteSize()}.
+     */
+    public static MemorySegment allocateArray(long elementCount, SegmentAllocator allocator) {
+        return allocator.allocate(MemoryLayout.sequenceLayout(elementCount, layout()));
     }
-    public static void max_idle_threads$set(MemorySegment seg, long index, int x) {
-        constants$2.const$2.set(seg.asSlice(index*sizeof()), x);
+
+    /**
+     * Reinterprets {@code addr} using target {@code arena} and {@code cleanupAction) (if any).
+     * The returned segment has size {@code layout().byteSize()}
+     */
+    public static MemorySegment reinterpret(MemorySegment addr, Arena arena, Consumer<MemorySegment> cleanup) {
+        return reinterpret(addr, 1, arena, cleanup);
     }
-    public static long sizeof() { return $LAYOUT().byteSize(); }
-    public static MemorySegment allocate(SegmentAllocator allocator) { return allocator.allocate($LAYOUT()); }
-    public static MemorySegment allocateArray(long len, SegmentAllocator allocator) {
-        return allocator.allocate(MemoryLayout.sequenceLayout(len, $LAYOUT()));
+
+    /**
+     * Reinterprets {@code addr} using target {@code arena} and {@code cleanupAction) (if any).
+     * The returned segment has size {@code elementCount * layout().byteSize()}
+     */
+    public static MemorySegment reinterpret(MemorySegment addr, long elementCount, Arena arena, Consumer<MemorySegment> cleanup) {
+        return addr.reinterpret(layout().byteSize() * elementCount, arena, cleanup);
     }
-    public static MemorySegment ofAddress(MemorySegment addr, Arena scope) { return RuntimeHelper.asArray(addr, $LAYOUT(), 1, scope); }
 }
 
-
diff --git a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/fuse_operations.java b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/fuse_operations.java
index ec8aef1c..3e81c2f4 100644
--- a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/fuse_operations.java
+++ b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/fuse_operations.java
@@ -2,2296 +2,4372 @@
 
 package org.cryptomator.jfuse.linux.amd64.extr.fuse3;
 
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
+import java.lang.invoke.*;
 import java.lang.foreign.*;
+import java.nio.ByteOrder;
+import java.util.*;
+import java.util.function.*;
+import java.util.stream.*;
+
 import static java.lang.foreign.ValueLayout.*;
+import static java.lang.foreign.MemoryLayout.PathElement.*;
+
 /**
- * {@snippet :
+ * {@snippet lang=c :
  * struct fuse_operations {
- *     int (*getattr)(char*,struct stat*,struct fuse_file_info*);
- *     int (*readlink)(char*,char*,unsigned long);
- *     int (*mknod)(char*,unsigned int,unsigned long);
- *     int (*mkdir)(char*,unsigned int);
- *     int (*unlink)(char*);
- *     int (*rmdir)(char*);
- *     int (*symlink)(char*,char*);
- *     int (*rename)(char*,char*,unsigned int);
- *     int (*link)(char*,char*);
- *     int (*chmod)(char*,unsigned int,struct fuse_file_info*);
- *     int (*chown)(char*,unsigned int,unsigned int,struct fuse_file_info*);
- *     int (*truncate)(char*,long,struct fuse_file_info*);
- *     int (*open)(char*,struct fuse_file_info*);
- *     int (*read)(char*,char*,unsigned long,long,struct fuse_file_info*);
- *     int (*write)(char*,char*,unsigned long,long,struct fuse_file_info*);
- *     int (*statfs)(char*,struct statvfs*);
- *     int (*flush)(char*,struct fuse_file_info*);
- *     int (*release)(char*,struct fuse_file_info*);
- *     int (*fsync)(char*,int,struct fuse_file_info*);
- *     int (*setxattr)(char*,char*,char*,unsigned long,int);
- *     int (*getxattr)(char*,char*,char*,unsigned long);
- *     int (*listxattr)(char*,char*,unsigned long);
- *     int (*removexattr)(char*,char*);
- *     int (*opendir)(char*,struct fuse_file_info*);
- *     int (*readdir)(char*,void*,int (*)(void*,char*,struct stat*,long,enum fuse_fill_dir_flags),long,struct fuse_file_info*,enum fuse_readdir_flags);
- *     int (*releasedir)(char*,struct fuse_file_info*);
- *     int (*fsyncdir)(char*,int,struct fuse_file_info*);
- *     void* (*init)(struct fuse_conn_info*,struct fuse_config*);
- *     void (*destroy)(void*);
- *     int (*access)(char*,int);
- *     int (*create)(char*,unsigned int,struct fuse_file_info*);
- *     int (*lock)(char*,struct fuse_file_info*,int,struct flock*);
- *     int (*utimens)(char*,struct timespec*,struct fuse_file_info*);
- *     int (*bmap)(char*,unsigned long,unsigned long*);
- *     int (*ioctl)(char*,unsigned int,void*,struct fuse_file_info*,unsigned int,void*);
- *     int (*poll)(char*,struct fuse_file_info*,struct fuse_pollhandle*,unsigned int*);
- *     int (*write_buf)(char*,struct fuse_bufvec*,long,struct fuse_file_info*);
- *     int (*read_buf)(char*,struct fuse_bufvec**,unsigned long,long,struct fuse_file_info*);
- *     int (*flock)(char*,struct fuse_file_info*,int);
- *     int (*fallocate)(char*,int,long,long,struct fuse_file_info*);
- *     long (*copy_file_range)(char*,struct fuse_file_info*,long,char*,struct fuse_file_info*,long,unsigned long,int);
- *     long (*lseek)(char*,long,int,struct fuse_file_info*);
- * };
+ *     int (*getattr)(const char *, struct stat *, struct fuse_file_info *);
+ *     int (*readlink)(const char *, char *, size_t);
+ *     int (*mknod)(const char *, mode_t, dev_t);
+ *     int (*mkdir)(const char *, mode_t);
+ *     int (*unlink)(const char *);
+ *     int (*rmdir)(const char *);
+ *     int (*symlink)(const char *, const char *);
+ *     int (*rename)(const char *, const char *, unsigned int);
+ *     int (*link)(const char *, const char *);
+ *     int (*chmod)(const char *, mode_t, struct fuse_file_info *);
+ *     int (*chown)(const char *, uid_t, gid_t, struct fuse_file_info *);
+ *     int (*truncate)(const char *, off_t, struct fuse_file_info *);
+ *     int (*open)(const char *, struct fuse_file_info *);
+ *     int (*read)(const char *, char *, size_t, off_t, struct fuse_file_info *);
+ *     int (*write)(const char *, const char *, size_t, off_t, struct fuse_file_info *);
+ *     int (*statfs)(const char *, struct statvfs *);
+ *     int (*flush)(const char *, struct fuse_file_info *);
+ *     int (*release)(const char *, struct fuse_file_info *);
+ *     int (*fsync)(const char *, int, struct fuse_file_info *);
+ *     int (*setxattr)(const char *, const char *, const char *, size_t, int);
+ *     int (*getxattr)(const char *, const char *, char *, size_t);
+ *     int (*listxattr)(const char *, char *, size_t);
+ *     int (*removexattr)(const char *, const char *);
+ *     int (*opendir)(const char *, struct fuse_file_info *);
+ *     int (*readdir)(const char *, void *, fuse_fill_dir_t, off_t, struct fuse_file_info *, enum fuse_readdir_flags);
+ *     int (*releasedir)(const char *, struct fuse_file_info *);
+ *     int (*fsyncdir)(const char *, int, struct fuse_file_info *);
+ *     void *(*init)(struct fuse_conn_info *, struct fuse_config *);
+ *     void (*destroy)(void *);
+ *     int (*access)(const char *, int);
+ *     int (*create)(const char *, mode_t, struct fuse_file_info *);
+ *     int (*lock)(const char *, struct fuse_file_info *, int, struct flock *);
+ *     int (*utimens)(const char *, const struct timespec *, struct fuse_file_info *);
+ *     int (*bmap)(const char *, size_t, uint64_t *);
+ *     int (*ioctl)(const char *, unsigned int, void *, struct fuse_file_info *, unsigned int, void *);
+ *     int (*poll)(const char *, struct fuse_file_info *, struct fuse_pollhandle *, unsigned int *);
+ *     int (*write_buf)(const char *, struct fuse_bufvec *, off_t, struct fuse_file_info *);
+ *     int (*read_buf)(const char *, struct fuse_bufvec **, size_t, off_t, struct fuse_file_info *);
+ *     int (*flock)(const char *, struct fuse_file_info *, int);
+ *     int (*fallocate)(const char *, int, off_t, off_t, struct fuse_file_info *);
+ *     ssize_t (*copy_file_range)(const char *, struct fuse_file_info *, off_t, const char *, struct fuse_file_info *, off_t, size_t, int);
+ *     off_t (*lseek)(const char *, off_t, int, struct fuse_file_info *);
+ * }
  * }
  */
 public class fuse_operations {
 
-    public static MemoryLayout $LAYOUT() {
-        return constants$14.const$4;
+    fuse_operations() {
+        // Should not be called directly
     }
+
+    private static final GroupLayout $LAYOUT = MemoryLayout.structLayout(
+        fuse_h.C_POINTER.withName("getattr"),
+        fuse_h.C_POINTER.withName("readlink"),
+        fuse_h.C_POINTER.withName("mknod"),
+        fuse_h.C_POINTER.withName("mkdir"),
+        fuse_h.C_POINTER.withName("unlink"),
+        fuse_h.C_POINTER.withName("rmdir"),
+        fuse_h.C_POINTER.withName("symlink"),
+        fuse_h.C_POINTER.withName("rename"),
+        fuse_h.C_POINTER.withName("link"),
+        fuse_h.C_POINTER.withName("chmod"),
+        fuse_h.C_POINTER.withName("chown"),
+        fuse_h.C_POINTER.withName("truncate"),
+        fuse_h.C_POINTER.withName("open"),
+        fuse_h.C_POINTER.withName("read"),
+        fuse_h.C_POINTER.withName("write"),
+        fuse_h.C_POINTER.withName("statfs"),
+        fuse_h.C_POINTER.withName("flush"),
+        fuse_h.C_POINTER.withName("release"),
+        fuse_h.C_POINTER.withName("fsync"),
+        fuse_h.C_POINTER.withName("setxattr"),
+        fuse_h.C_POINTER.withName("getxattr"),
+        fuse_h.C_POINTER.withName("listxattr"),
+        fuse_h.C_POINTER.withName("removexattr"),
+        fuse_h.C_POINTER.withName("opendir"),
+        fuse_h.C_POINTER.withName("readdir"),
+        fuse_h.C_POINTER.withName("releasedir"),
+        fuse_h.C_POINTER.withName("fsyncdir"),
+        fuse_h.C_POINTER.withName("init"),
+        fuse_h.C_POINTER.withName("destroy"),
+        fuse_h.C_POINTER.withName("access"),
+        fuse_h.C_POINTER.withName("create"),
+        fuse_h.C_POINTER.withName("lock"),
+        fuse_h.C_POINTER.withName("utimens"),
+        fuse_h.C_POINTER.withName("bmap"),
+        fuse_h.C_POINTER.withName("ioctl"),
+        fuse_h.C_POINTER.withName("poll"),
+        fuse_h.C_POINTER.withName("write_buf"),
+        fuse_h.C_POINTER.withName("read_buf"),
+        fuse_h.C_POINTER.withName("flock"),
+        fuse_h.C_POINTER.withName("fallocate"),
+        fuse_h.C_POINTER.withName("copy_file_range"),
+        fuse_h.C_POINTER.withName("lseek")
+    ).withName("fuse_operations");
+
     /**
-     * {@snippet :
- * int (*getattr)(char*,struct stat*,struct fuse_file_info*);
-     * }
+     * The layout of this struct
      */
-    public interface getattr {
-
-        int apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1, java.lang.foreign.MemorySegment _x2);
-        static MemorySegment allocate(getattr fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$15.const$0, fi, constants$14.const$5, scope);
-        }
-        static getattr ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1, java.lang.foreign.MemorySegment __x2) -> {
-                try {
-                    return (int)constants$15.const$1.invokeExact(symbol, __x0, __x1, __x2);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
-        }
+    public static final GroupLayout layout() {
+        return $LAYOUT;
     }
 
-    public static VarHandle getattr$VH() {
-        return constants$15.const$2;
-    }
     /**
-     * Getter for field:
-     * {@snippet :
-     * int (*getattr)(char*,struct stat*,struct fuse_file_info*);
+     * {@snippet lang=c :
+     * int (*getattr)(const char *, struct stat *, struct fuse_file_info *)
      * }
      */
-    public static MemorySegment getattr$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$15.const$2.get(seg);
+    public static class getattr {
+
+        getattr() {
+            // Should not be called directly
+        }
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, MemorySegment _x1, MemorySegment _x2);
+        }
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(getattr.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(getattr.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1, MemorySegment _x2) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
     }
+
+    private static final AddressLayout getattr$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("getattr"));
+
     /**
-     * Setter for field:
-     * {@snippet :
-     * int (*getattr)(char*,struct stat*,struct fuse_file_info*);
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*getattr)(const char *, struct stat *, struct fuse_file_info *)
      * }
      */
-    public static void getattr$set(MemorySegment seg, MemorySegment x) {
-        constants$15.const$2.set(seg, x);
-    }
-    public static MemorySegment getattr$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$15.const$2.get(seg.asSlice(index*sizeof()));
-    }
-    public static void getattr$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$15.const$2.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static getattr getattr(MemorySegment segment, Arena scope) {
-        return getattr.ofAddress(getattr$get(segment), scope);
+    public static final AddressLayout getattr$layout() {
+        return getattr$LAYOUT;
     }
+
+    private static final long getattr$OFFSET = 0;
+
     /**
-     * {@snippet :
- * int (*readlink)(char*,char*,unsigned long);
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*getattr)(const char *, struct stat *, struct fuse_file_info *)
      * }
      */
-    public interface readlink {
-
-        int apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1, long _x2);
-        static MemorySegment allocate(readlink fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$15.const$4, fi, constants$15.const$3, scope);
-        }
-        static readlink ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1, long __x2) -> {
-                try {
-                    return (int)constants$15.const$5.invokeExact(symbol, __x0, __x1, __x2);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
-        }
+    public static final long getattr$offset() {
+        return getattr$OFFSET;
     }
 
-    public static VarHandle readlink$VH() {
-        return constants$16.const$0;
-    }
     /**
      * Getter for field:
-     * {@snippet :
-     * int (*readlink)(char*,char*,unsigned long);
+     * {@snippet lang=c :
+     * int (*getattr)(const char *, struct stat *, struct fuse_file_info *)
      * }
      */
-    public static MemorySegment readlink$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$16.const$0.get(seg);
+    public static MemorySegment getattr(MemorySegment struct) {
+        return struct.get(getattr$LAYOUT, getattr$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int (*readlink)(char*,char*,unsigned long);
+     * {@snippet lang=c :
+     * int (*getattr)(const char *, struct stat *, struct fuse_file_info *)
      * }
      */
-    public static void readlink$set(MemorySegment seg, MemorySegment x) {
-        constants$16.const$0.set(seg, x);
-    }
-    public static MemorySegment readlink$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$16.const$0.get(seg.asSlice(index*sizeof()));
-    }
-    public static void readlink$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$16.const$0.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static readlink readlink(MemorySegment segment, Arena scope) {
-        return readlink.ofAddress(readlink$get(segment), scope);
+    public static void getattr(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(getattr$LAYOUT, getattr$OFFSET, fieldValue);
     }
+
     /**
-     * {@snippet :
- * int (*mknod)(char*,unsigned int,unsigned long);
+     * {@snippet lang=c :
+     * int (*readlink)(const char *, char *, size_t)
      * }
      */
-    public interface mknod {
+    public static class readlink {
 
-        int apply(java.lang.foreign.MemorySegment _x0, int _x1, long _x2);
-        static MemorySegment allocate(mknod fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$16.const$2, fi, constants$16.const$1, scope);
+        readlink() {
+            // Should not be called directly
         }
-        static mknod ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, int __x1, long __x2) -> {
-                try {
-                    return (int)constants$16.const$3.invokeExact(symbol, __x0, __x1, __x2);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, MemorySegment _x1, long _x2);
         }
-    }
 
-    public static VarHandle mknod$VH() {
-        return constants$16.const$4;
-    }
-    /**
-     * Getter for field:
-     * {@snippet :
-     * int (*mknod)(char*,unsigned int,unsigned long);
-     * }
-     */
-    public static MemorySegment mknod$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$16.const$4.get(seg);
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER,
+            fuse_h.C_LONG
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(readlink.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(readlink.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1, long _x2) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
     }
+
+    private static final AddressLayout readlink$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("readlink"));
+
     /**
-     * Setter for field:
-     * {@snippet :
-     * int (*mknod)(char*,unsigned int,unsigned long);
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*readlink)(const char *, char *, size_t)
      * }
      */
-    public static void mknod$set(MemorySegment seg, MemorySegment x) {
-        constants$16.const$4.set(seg, x);
-    }
-    public static MemorySegment mknod$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$16.const$4.get(seg.asSlice(index*sizeof()));
-    }
-    public static void mknod$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$16.const$4.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static mknod mknod(MemorySegment segment, Arena scope) {
-        return mknod.ofAddress(mknod$get(segment), scope);
+    public static final AddressLayout readlink$layout() {
+        return readlink$LAYOUT;
     }
+
+    private static final long readlink$OFFSET = 8;
+
     /**
-     * {@snippet :
- * int (*mkdir)(char*,unsigned int);
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*readlink)(const char *, char *, size_t)
      * }
      */
-    public interface mkdir {
-
-        int apply(java.lang.foreign.MemorySegment _x0, int _x1);
-        static MemorySegment allocate(mkdir fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$17.const$0, fi, constants$16.const$5, scope);
-        }
-        static mkdir ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, int __x1) -> {
-                try {
-                    return (int)constants$17.const$1.invokeExact(symbol, __x0, __x1);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
-        }
+    public static final long readlink$offset() {
+        return readlink$OFFSET;
     }
 
-    public static VarHandle mkdir$VH() {
-        return constants$17.const$2;
-    }
     /**
      * Getter for field:
-     * {@snippet :
-     * int (*mkdir)(char*,unsigned int);
+     * {@snippet lang=c :
+     * int (*readlink)(const char *, char *, size_t)
      * }
      */
-    public static MemorySegment mkdir$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$17.const$2.get(seg);
+    public static MemorySegment readlink(MemorySegment struct) {
+        return struct.get(readlink$LAYOUT, readlink$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int (*mkdir)(char*,unsigned int);
+     * {@snippet lang=c :
+     * int (*readlink)(const char *, char *, size_t)
      * }
      */
-    public static void mkdir$set(MemorySegment seg, MemorySegment x) {
-        constants$17.const$2.set(seg, x);
-    }
-    public static MemorySegment mkdir$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$17.const$2.get(seg.asSlice(index*sizeof()));
-    }
-    public static void mkdir$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$17.const$2.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static mkdir mkdir(MemorySegment segment, Arena scope) {
-        return mkdir.ofAddress(mkdir$get(segment), scope);
+    public static void readlink(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(readlink$LAYOUT, readlink$OFFSET, fieldValue);
     }
+
     /**
-     * {@snippet :
- * int (*unlink)(char*);
+     * {@snippet lang=c :
+     * int (*mknod)(const char *, mode_t, dev_t)
      * }
      */
-    public interface unlink {
+    public static class mknod {
 
-        int apply(java.lang.foreign.MemorySegment _x0);
-        static MemorySegment allocate(unlink fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$17.const$4, fi, constants$17.const$3, scope);
+        mknod() {
+            // Should not be called directly
         }
-        static unlink ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0) -> {
-                try {
-                    return (int)constants$17.const$5.invokeExact(symbol, __x0);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, int _x1, long _x2);
         }
-    }
 
-    public static VarHandle unlink$VH() {
-        return constants$18.const$0;
-    }
-    /**
-     * Getter for field:
-     * {@snippet :
-     * int (*unlink)(char*);
-     * }
-     */
-    public static MemorySegment unlink$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$18.const$0.get(seg);
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_INT,
+            fuse_h.C_LONG
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(mknod.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(mknod.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, int _x1, long _x2) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
     }
+
+    private static final AddressLayout mknod$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("mknod"));
+
     /**
-     * Setter for field:
-     * {@snippet :
-     * int (*unlink)(char*);
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*mknod)(const char *, mode_t, dev_t)
      * }
      */
-    public static void unlink$set(MemorySegment seg, MemorySegment x) {
-        constants$18.const$0.set(seg, x);
-    }
-    public static MemorySegment unlink$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$18.const$0.get(seg.asSlice(index*sizeof()));
-    }
-    public static void unlink$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$18.const$0.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static unlink unlink(MemorySegment segment, Arena scope) {
-        return unlink.ofAddress(unlink$get(segment), scope);
+    public static final AddressLayout mknod$layout() {
+        return mknod$LAYOUT;
     }
+
+    private static final long mknod$OFFSET = 16;
+
     /**
-     * {@snippet :
- * int (*rmdir)(char*);
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*mknod)(const char *, mode_t, dev_t)
      * }
      */
-    public interface rmdir {
-
-        int apply(java.lang.foreign.MemorySegment _x0);
-        static MemorySegment allocate(rmdir fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$18.const$1, fi, constants$17.const$3, scope);
-        }
-        static rmdir ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0) -> {
-                try {
-                    return (int)constants$17.const$5.invokeExact(symbol, __x0);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
-        }
+    public static final long mknod$offset() {
+        return mknod$OFFSET;
     }
 
-    public static VarHandle rmdir$VH() {
-        return constants$18.const$2;
-    }
     /**
      * Getter for field:
-     * {@snippet :
-     * int (*rmdir)(char*);
+     * {@snippet lang=c :
+     * int (*mknod)(const char *, mode_t, dev_t)
      * }
      */
-    public static MemorySegment rmdir$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$18.const$2.get(seg);
+    public static MemorySegment mknod(MemorySegment struct) {
+        return struct.get(mknod$LAYOUT, mknod$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int (*rmdir)(char*);
+     * {@snippet lang=c :
+     * int (*mknod)(const char *, mode_t, dev_t)
      * }
      */
-    public static void rmdir$set(MemorySegment seg, MemorySegment x) {
-        constants$18.const$2.set(seg, x);
-    }
-    public static MemorySegment rmdir$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$18.const$2.get(seg.asSlice(index*sizeof()));
-    }
-    public static void rmdir$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$18.const$2.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static rmdir rmdir(MemorySegment segment, Arena scope) {
-        return rmdir.ofAddress(rmdir$get(segment), scope);
+    public static void mknod(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(mknod$LAYOUT, mknod$OFFSET, fieldValue);
     }
+
     /**
-     * {@snippet :
- * int (*symlink)(char*,char*);
+     * {@snippet lang=c :
+     * int (*mkdir)(const char *, mode_t)
      * }
      */
-    public interface symlink {
+    public static class mkdir {
 
-        int apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1);
-        static MemorySegment allocate(symlink fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$18.const$4, fi, constants$18.const$3, scope);
+        mkdir() {
+            // Should not be called directly
         }
-        static symlink ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1) -> {
-                try {
-                    return (int)constants$18.const$5.invokeExact(symbol, __x0, __x1);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, int _x1);
         }
-    }
 
-    public static VarHandle symlink$VH() {
-        return constants$19.const$0;
-    }
-    /**
-     * Getter for field:
-     * {@snippet :
-     * int (*symlink)(char*,char*);
-     * }
-     */
-    public static MemorySegment symlink$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$19.const$0.get(seg);
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_INT
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(mkdir.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(mkdir.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, int _x1) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
     }
+
+    private static final AddressLayout mkdir$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("mkdir"));
+
     /**
-     * Setter for field:
-     * {@snippet :
-     * int (*symlink)(char*,char*);
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*mkdir)(const char *, mode_t)
      * }
      */
-    public static void symlink$set(MemorySegment seg, MemorySegment x) {
-        constants$19.const$0.set(seg, x);
-    }
-    public static MemorySegment symlink$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$19.const$0.get(seg.asSlice(index*sizeof()));
-    }
-    public static void symlink$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$19.const$0.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static symlink symlink(MemorySegment segment, Arena scope) {
-        return symlink.ofAddress(symlink$get(segment), scope);
+    public static final AddressLayout mkdir$layout() {
+        return mkdir$LAYOUT;
     }
+
+    private static final long mkdir$OFFSET = 24;
+
     /**
-     * {@snippet :
- * int (*rename)(char*,char*,unsigned int);
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*mkdir)(const char *, mode_t)
      * }
      */
-    public interface rename {
-
-        int apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1, int _x2);
-        static MemorySegment allocate(rename fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$19.const$2, fi, constants$19.const$1, scope);
-        }
-        static rename ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1, int __x2) -> {
-                try {
-                    return (int)constants$19.const$3.invokeExact(symbol, __x0, __x1, __x2);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
-        }
+    public static final long mkdir$offset() {
+        return mkdir$OFFSET;
     }
 
-    public static VarHandle rename$VH() {
-        return constants$19.const$4;
-    }
     /**
      * Getter for field:
-     * {@snippet :
-     * int (*rename)(char*,char*,unsigned int);
+     * {@snippet lang=c :
+     * int (*mkdir)(const char *, mode_t)
      * }
      */
-    public static MemorySegment rename$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$19.const$4.get(seg);
+    public static MemorySegment mkdir(MemorySegment struct) {
+        return struct.get(mkdir$LAYOUT, mkdir$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int (*rename)(char*,char*,unsigned int);
+     * {@snippet lang=c :
+     * int (*mkdir)(const char *, mode_t)
      * }
      */
-    public static void rename$set(MemorySegment seg, MemorySegment x) {
-        constants$19.const$4.set(seg, x);
-    }
-    public static MemorySegment rename$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$19.const$4.get(seg.asSlice(index*sizeof()));
-    }
-    public static void rename$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$19.const$4.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static rename rename(MemorySegment segment, Arena scope) {
-        return rename.ofAddress(rename$get(segment), scope);
+    public static void mkdir(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(mkdir$LAYOUT, mkdir$OFFSET, fieldValue);
     }
+
     /**
-     * {@snippet :
- * int (*link)(char*,char*);
+     * {@snippet lang=c :
+     * int (*unlink)(const char *)
      * }
      */
-    public interface link {
+    public static class unlink {
 
-        int apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1);
-        static MemorySegment allocate(link fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$19.const$5, fi, constants$18.const$3, scope);
+        unlink() {
+            // Should not be called directly
         }
-        static link ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1) -> {
-                try {
-                    return (int)constants$18.const$5.invokeExact(symbol, __x0, __x1);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0);
         }
-    }
 
-    public static VarHandle link$VH() {
-        return constants$20.const$0;
-    }
-    /**
-     * Getter for field:
-     * {@snippet :
-     * int (*link)(char*,char*);
-     * }
-     */
-    public static MemorySegment link$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$20.const$0.get(seg);
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(unlink.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(unlink.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
     }
+
+    private static final AddressLayout unlink$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("unlink"));
+
     /**
-     * Setter for field:
-     * {@snippet :
-     * int (*link)(char*,char*);
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*unlink)(const char *)
      * }
      */
-    public static void link$set(MemorySegment seg, MemorySegment x) {
-        constants$20.const$0.set(seg, x);
-    }
-    public static MemorySegment link$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$20.const$0.get(seg.asSlice(index*sizeof()));
-    }
-    public static void link$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$20.const$0.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static link link(MemorySegment segment, Arena scope) {
-        return link.ofAddress(link$get(segment), scope);
+    public static final AddressLayout unlink$layout() {
+        return unlink$LAYOUT;
     }
+
+    private static final long unlink$OFFSET = 32;
+
     /**
-     * {@snippet :
- * int (*chmod)(char*,unsigned int,struct fuse_file_info*);
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*unlink)(const char *)
      * }
      */
-    public interface chmod {
-
-        int apply(java.lang.foreign.MemorySegment _x0, int _x1, java.lang.foreign.MemorySegment _x2);
-        static MemorySegment allocate(chmod fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$20.const$2, fi, constants$20.const$1, scope);
-        }
-        static chmod ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, int __x1, java.lang.foreign.MemorySegment __x2) -> {
-                try {
-                    return (int)constants$20.const$3.invokeExact(symbol, __x0, __x1, __x2);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
-        }
+    public static final long unlink$offset() {
+        return unlink$OFFSET;
     }
 
-    public static VarHandle chmod$VH() {
-        return constants$20.const$4;
-    }
     /**
      * Getter for field:
-     * {@snippet :
-     * int (*chmod)(char*,unsigned int,struct fuse_file_info*);
+     * {@snippet lang=c :
+     * int (*unlink)(const char *)
      * }
      */
-    public static MemorySegment chmod$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$20.const$4.get(seg);
+    public static MemorySegment unlink(MemorySegment struct) {
+        return struct.get(unlink$LAYOUT, unlink$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int (*chmod)(char*,unsigned int,struct fuse_file_info*);
+     * {@snippet lang=c :
+     * int (*unlink)(const char *)
      * }
      */
-    public static void chmod$set(MemorySegment seg, MemorySegment x) {
-        constants$20.const$4.set(seg, x);
-    }
-    public static MemorySegment chmod$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$20.const$4.get(seg.asSlice(index*sizeof()));
-    }
-    public static void chmod$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$20.const$4.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static chmod chmod(MemorySegment segment, Arena scope) {
-        return chmod.ofAddress(chmod$get(segment), scope);
+    public static void unlink(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(unlink$LAYOUT, unlink$OFFSET, fieldValue);
     }
+
     /**
-     * {@snippet :
- * int (*chown)(char*,unsigned int,unsigned int,struct fuse_file_info*);
+     * {@snippet lang=c :
+     * int (*rmdir)(const char *)
      * }
      */
-    public interface chown {
+    public static class rmdir {
 
-        int apply(java.lang.foreign.MemorySegment _x0, int _x1, int _x2, java.lang.foreign.MemorySegment _x3);
-        static MemorySegment allocate(chown fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$21.const$0, fi, constants$20.const$5, scope);
+        rmdir() {
+            // Should not be called directly
         }
-        static chown ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, int __x1, int __x2, java.lang.foreign.MemorySegment __x3) -> {
-                try {
-                    return (int)constants$21.const$1.invokeExact(symbol, __x0, __x1, __x2, __x3);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0);
         }
-    }
 
-    public static VarHandle chown$VH() {
-        return constants$21.const$2;
-    }
-    /**
-     * Getter for field:
-     * {@snippet :
-     * int (*chown)(char*,unsigned int,unsigned int,struct fuse_file_info*);
-     * }
-     */
-    public static MemorySegment chown$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$21.const$2.get(seg);
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(rmdir.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(rmdir.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
     }
+
+    private static final AddressLayout rmdir$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("rmdir"));
+
     /**
-     * Setter for field:
-     * {@snippet :
-     * int (*chown)(char*,unsigned int,unsigned int,struct fuse_file_info*);
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*rmdir)(const char *)
      * }
      */
-    public static void chown$set(MemorySegment seg, MemorySegment x) {
-        constants$21.const$2.set(seg, x);
-    }
-    public static MemorySegment chown$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$21.const$2.get(seg.asSlice(index*sizeof()));
-    }
-    public static void chown$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$21.const$2.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static chown chown(MemorySegment segment, Arena scope) {
-        return chown.ofAddress(chown$get(segment), scope);
+    public static final AddressLayout rmdir$layout() {
+        return rmdir$LAYOUT;
     }
+
+    private static final long rmdir$OFFSET = 40;
+
     /**
-     * {@snippet :
- * int (*truncate)(char*,long,struct fuse_file_info*);
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*rmdir)(const char *)
      * }
      */
-    public interface truncate {
-
-        int apply(java.lang.foreign.MemorySegment _x0, long _x1, java.lang.foreign.MemorySegment _x2);
-        static MemorySegment allocate(truncate fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$21.const$4, fi, constants$21.const$3, scope);
-        }
-        static truncate ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, long __x1, java.lang.foreign.MemorySegment __x2) -> {
-                try {
-                    return (int)constants$21.const$5.invokeExact(symbol, __x0, __x1, __x2);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
-        }
+    public static final long rmdir$offset() {
+        return rmdir$OFFSET;
     }
 
-    public static VarHandle truncate$VH() {
-        return constants$22.const$0;
-    }
     /**
      * Getter for field:
-     * {@snippet :
-     * int (*truncate)(char*,long,struct fuse_file_info*);
+     * {@snippet lang=c :
+     * int (*rmdir)(const char *)
      * }
      */
-    public static MemorySegment truncate$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$22.const$0.get(seg);
+    public static MemorySegment rmdir(MemorySegment struct) {
+        return struct.get(rmdir$LAYOUT, rmdir$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int (*truncate)(char*,long,struct fuse_file_info*);
+     * {@snippet lang=c :
+     * int (*rmdir)(const char *)
      * }
      */
-    public static void truncate$set(MemorySegment seg, MemorySegment x) {
-        constants$22.const$0.set(seg, x);
-    }
-    public static MemorySegment truncate$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$22.const$0.get(seg.asSlice(index*sizeof()));
-    }
-    public static void truncate$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$22.const$0.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static truncate truncate(MemorySegment segment, Arena scope) {
-        return truncate.ofAddress(truncate$get(segment), scope);
+    public static void rmdir(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(rmdir$LAYOUT, rmdir$OFFSET, fieldValue);
     }
+
     /**
-     * {@snippet :
- * int (*open)(char*,struct fuse_file_info*);
+     * {@snippet lang=c :
+     * int (*symlink)(const char *, const char *)
      * }
      */
-    public interface open {
+    public static class symlink {
 
-        int apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1);
-        static MemorySegment allocate(open fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$22.const$1, fi, constants$18.const$3, scope);
+        symlink() {
+            // Should not be called directly
         }
-        static open ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1) -> {
-                try {
-                    return (int)constants$18.const$5.invokeExact(symbol, __x0, __x1);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, MemorySegment _x1);
         }
-    }
 
-    public static VarHandle open$VH() {
-        return constants$22.const$2;
-    }
-    /**
-     * Getter for field:
-     * {@snippet :
-     * int (*open)(char*,struct fuse_file_info*);
-     * }
-     */
-    public static MemorySegment open$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$22.const$2.get(seg);
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(symlink.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(symlink.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
     }
+
+    private static final AddressLayout symlink$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("symlink"));
+
     /**
-     * Setter for field:
-     * {@snippet :
-     * int (*open)(char*,struct fuse_file_info*);
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*symlink)(const char *, const char *)
      * }
      */
-    public static void open$set(MemorySegment seg, MemorySegment x) {
-        constants$22.const$2.set(seg, x);
-    }
-    public static MemorySegment open$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$22.const$2.get(seg.asSlice(index*sizeof()));
-    }
-    public static void open$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$22.const$2.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static open open(MemorySegment segment, Arena scope) {
-        return open.ofAddress(open$get(segment), scope);
+    public static final AddressLayout symlink$layout() {
+        return symlink$LAYOUT;
     }
+
+    private static final long symlink$OFFSET = 48;
+
     /**
-     * {@snippet :
- * int (*read)(char*,char*,unsigned long,long,struct fuse_file_info*);
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*symlink)(const char *, const char *)
      * }
      */
-    public interface read {
-
-        int apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1, long _x2, long _x3, java.lang.foreign.MemorySegment _x4);
-        static MemorySegment allocate(read fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$22.const$4, fi, constants$22.const$3, scope);
-        }
-        static read ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1, long __x2, long __x3, java.lang.foreign.MemorySegment __x4) -> {
-                try {
-                    return (int)constants$22.const$5.invokeExact(symbol, __x0, __x1, __x2, __x3, __x4);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
-        }
+    public static final long symlink$offset() {
+        return symlink$OFFSET;
     }
 
-    public static VarHandle read$VH() {
-        return constants$23.const$0;
-    }
     /**
      * Getter for field:
-     * {@snippet :
-     * int (*read)(char*,char*,unsigned long,long,struct fuse_file_info*);
+     * {@snippet lang=c :
+     * int (*symlink)(const char *, const char *)
      * }
      */
-    public static MemorySegment read$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$23.const$0.get(seg);
+    public static MemorySegment symlink(MemorySegment struct) {
+        return struct.get(symlink$LAYOUT, symlink$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int (*read)(char*,char*,unsigned long,long,struct fuse_file_info*);
+     * {@snippet lang=c :
+     * int (*symlink)(const char *, const char *)
      * }
      */
-    public static void read$set(MemorySegment seg, MemorySegment x) {
-        constants$23.const$0.set(seg, x);
-    }
-    public static MemorySegment read$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$23.const$0.get(seg.asSlice(index*sizeof()));
-    }
-    public static void read$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$23.const$0.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static read read(MemorySegment segment, Arena scope) {
-        return read.ofAddress(read$get(segment), scope);
+    public static void symlink(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(symlink$LAYOUT, symlink$OFFSET, fieldValue);
     }
+
     /**
-     * {@snippet :
- * int (*write)(char*,char*,unsigned long,long,struct fuse_file_info*);
+     * {@snippet lang=c :
+     * int (*rename)(const char *, const char *, unsigned int)
      * }
      */
-    public interface write {
+    public static class rename {
+
+        rename() {
+            // Should not be called directly
+        }
 
-        int apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1, long _x2, long _x3, java.lang.foreign.MemorySegment _x4);
-        static MemorySegment allocate(write fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$23.const$1, fi, constants$22.const$3, scope);
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, MemorySegment _x1, int _x2);
         }
-        static write ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1, long __x2, long __x3, java.lang.foreign.MemorySegment __x4) -> {
-                try {
-                    return (int)constants$22.const$5.invokeExact(symbol, __x0, __x1, __x2, __x3, __x4);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER,
+            fuse_h.C_INT
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
         }
-    }
 
-    public static VarHandle write$VH() {
-        return constants$23.const$2;
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(rename.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(rename.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1, int _x2) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
     }
+
+    private static final AddressLayout rename$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("rename"));
+
     /**
-     * Getter for field:
-     * {@snippet :
-     * int (*write)(char*,char*,unsigned long,long,struct fuse_file_info*);
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*rename)(const char *, const char *, unsigned int)
      * }
      */
-    public static MemorySegment write$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$23.const$2.get(seg);
+    public static final AddressLayout rename$layout() {
+        return rename$LAYOUT;
     }
+
+    private static final long rename$OFFSET = 56;
+
     /**
-     * Setter for field:
-     * {@snippet :
-     * int (*write)(char*,char*,unsigned long,long,struct fuse_file_info*);
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*rename)(const char *, const char *, unsigned int)
      * }
      */
-    public static void write$set(MemorySegment seg, MemorySegment x) {
-        constants$23.const$2.set(seg, x);
-    }
-    public static MemorySegment write$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$23.const$2.get(seg.asSlice(index*sizeof()));
-    }
-    public static void write$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$23.const$2.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static write write(MemorySegment segment, Arena scope) {
-        return write.ofAddress(write$get(segment), scope);
+    public static final long rename$offset() {
+        return rename$OFFSET;
     }
+
     /**
-     * {@snippet :
- * int (*statfs)(char*,struct statvfs*);
+     * Getter for field:
+     * {@snippet lang=c :
+     * int (*rename)(const char *, const char *, unsigned int)
      * }
      */
-    public interface statfs {
-
-        int apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1);
-        static MemorySegment allocate(statfs fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$23.const$3, fi, constants$18.const$3, scope);
-        }
-        static statfs ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1) -> {
-                try {
-                    return (int)constants$18.const$5.invokeExact(symbol, __x0, __x1);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
-        }
+    public static MemorySegment rename(MemorySegment struct) {
+        return struct.get(rename$LAYOUT, rename$OFFSET);
     }
 
-    public static VarHandle statfs$VH() {
-        return constants$23.const$4;
-    }
-    /**
-     * Getter for field:
-     * {@snippet :
-     * int (*statfs)(char*,struct statvfs*);
-     * }
-     */
-    public static MemorySegment statfs$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$23.const$4.get(seg);
-    }
     /**
      * Setter for field:
-     * {@snippet :
-     * int (*statfs)(char*,struct statvfs*);
+     * {@snippet lang=c :
+     * int (*rename)(const char *, const char *, unsigned int)
      * }
      */
-    public static void statfs$set(MemorySegment seg, MemorySegment x) {
-        constants$23.const$4.set(seg, x);
-    }
-    public static MemorySegment statfs$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$23.const$4.get(seg.asSlice(index*sizeof()));
-    }
-    public static void statfs$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$23.const$4.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static statfs statfs(MemorySegment segment, Arena scope) {
-        return statfs.ofAddress(statfs$get(segment), scope);
+    public static void rename(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(rename$LAYOUT, rename$OFFSET, fieldValue);
     }
+
     /**
-     * {@snippet :
- * int (*flush)(char*,struct fuse_file_info*);
+     * {@snippet lang=c :
+     * int (*link)(const char *, const char *)
      * }
      */
-    public interface flush {
+    public static class link {
+
+        link() {
+            // Should not be called directly
+        }
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, MemorySegment _x1);
+        }
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
 
-        int apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1);
-        static MemorySegment allocate(flush fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$23.const$5, fi, constants$18.const$3, scope);
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(link.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(link.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
         }
-        static flush ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1) -> {
-                try {
-                    return (int)constants$18.const$5.invokeExact(symbol, __x0, __x1);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
         }
     }
 
-    public static VarHandle flush$VH() {
-        return constants$24.const$0;
+    private static final AddressLayout link$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("link"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*link)(const char *, const char *)
+     * }
+     */
+    public static final AddressLayout link$layout() {
+        return link$LAYOUT;
+    }
+
+    private static final long link$OFFSET = 64;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*link)(const char *, const char *)
+     * }
+     */
+    public static final long link$offset() {
+        return link$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int (*flush)(char*,struct fuse_file_info*);
+     * {@snippet lang=c :
+     * int (*link)(const char *, const char *)
      * }
      */
-    public static MemorySegment flush$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$24.const$0.get(seg);
+    public static MemorySegment link(MemorySegment struct) {
+        return struct.get(link$LAYOUT, link$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int (*flush)(char*,struct fuse_file_info*);
+     * {@snippet lang=c :
+     * int (*link)(const char *, const char *)
      * }
      */
-    public static void flush$set(MemorySegment seg, MemorySegment x) {
-        constants$24.const$0.set(seg, x);
-    }
-    public static MemorySegment flush$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$24.const$0.get(seg.asSlice(index*sizeof()));
-    }
-    public static void flush$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$24.const$0.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static flush flush(MemorySegment segment, Arena scope) {
-        return flush.ofAddress(flush$get(segment), scope);
+    public static void link(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(link$LAYOUT, link$OFFSET, fieldValue);
     }
+
     /**
-     * {@snippet :
- * int (*release)(char*,struct fuse_file_info*);
+     * {@snippet lang=c :
+     * int (*chmod)(const char *, mode_t, struct fuse_file_info *)
      * }
      */
-    public interface release {
+    public static class chmod {
+
+        chmod() {
+            // Should not be called directly
+        }
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, int _x1, MemorySegment _x2);
+        }
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_INT,
+            fuse_h.C_POINTER
+        );
 
-        int apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1);
-        static MemorySegment allocate(release fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$24.const$1, fi, constants$18.const$3, scope);
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
         }
-        static release ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1) -> {
-                try {
-                    return (int)constants$18.const$5.invokeExact(symbol, __x0, __x1);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(chmod.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(chmod.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, int _x1, MemorySegment _x2) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
         }
     }
 
-    public static VarHandle release$VH() {
-        return constants$24.const$2;
+    private static final AddressLayout chmod$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("chmod"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*chmod)(const char *, mode_t, struct fuse_file_info *)
+     * }
+     */
+    public static final AddressLayout chmod$layout() {
+        return chmod$LAYOUT;
+    }
+
+    private static final long chmod$OFFSET = 72;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*chmod)(const char *, mode_t, struct fuse_file_info *)
+     * }
+     */
+    public static final long chmod$offset() {
+        return chmod$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int (*release)(char*,struct fuse_file_info*);
+     * {@snippet lang=c :
+     * int (*chmod)(const char *, mode_t, struct fuse_file_info *)
      * }
      */
-    public static MemorySegment release$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$24.const$2.get(seg);
+    public static MemorySegment chmod(MemorySegment struct) {
+        return struct.get(chmod$LAYOUT, chmod$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int (*release)(char*,struct fuse_file_info*);
+     * {@snippet lang=c :
+     * int (*chmod)(const char *, mode_t, struct fuse_file_info *)
      * }
      */
-    public static void release$set(MemorySegment seg, MemorySegment x) {
-        constants$24.const$2.set(seg, x);
-    }
-    public static MemorySegment release$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$24.const$2.get(seg.asSlice(index*sizeof()));
-    }
-    public static void release$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$24.const$2.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static release release(MemorySegment segment, Arena scope) {
-        return release.ofAddress(release$get(segment), scope);
+    public static void chmod(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(chmod$LAYOUT, chmod$OFFSET, fieldValue);
     }
+
     /**
-     * {@snippet :
- * int (*fsync)(char*,int,struct fuse_file_info*);
+     * {@snippet lang=c :
+     * int (*chown)(const char *, uid_t, gid_t, struct fuse_file_info *)
      * }
      */
-    public interface fsync {
+    public static class chown {
+
+        chown() {
+            // Should not be called directly
+        }
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, int _x1, int _x2, MemorySegment _x3);
+        }
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_INT,
+            fuse_h.C_INT,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
 
-        int apply(java.lang.foreign.MemorySegment _x0, int _x1, java.lang.foreign.MemorySegment _x2);
-        static MemorySegment allocate(fsync fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$24.const$3, fi, constants$20.const$1, scope);
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(chown.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(chown.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
         }
-        static fsync ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, int __x1, java.lang.foreign.MemorySegment __x2) -> {
-                try {
-                    return (int)constants$20.const$3.invokeExact(symbol, __x0, __x1, __x2);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, int _x1, int _x2, MemorySegment _x3) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2, _x3);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
         }
     }
 
-    public static VarHandle fsync$VH() {
-        return constants$24.const$4;
+    private static final AddressLayout chown$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("chown"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*chown)(const char *, uid_t, gid_t, struct fuse_file_info *)
+     * }
+     */
+    public static final AddressLayout chown$layout() {
+        return chown$LAYOUT;
+    }
+
+    private static final long chown$OFFSET = 80;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*chown)(const char *, uid_t, gid_t, struct fuse_file_info *)
+     * }
+     */
+    public static final long chown$offset() {
+        return chown$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int (*fsync)(char*,int,struct fuse_file_info*);
+     * {@snippet lang=c :
+     * int (*chown)(const char *, uid_t, gid_t, struct fuse_file_info *)
      * }
      */
-    public static MemorySegment fsync$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$24.const$4.get(seg);
+    public static MemorySegment chown(MemorySegment struct) {
+        return struct.get(chown$LAYOUT, chown$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int (*fsync)(char*,int,struct fuse_file_info*);
+     * {@snippet lang=c :
+     * int (*chown)(const char *, uid_t, gid_t, struct fuse_file_info *)
      * }
      */
-    public static void fsync$set(MemorySegment seg, MemorySegment x) {
-        constants$24.const$4.set(seg, x);
-    }
-    public static MemorySegment fsync$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$24.const$4.get(seg.asSlice(index*sizeof()));
-    }
-    public static void fsync$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$24.const$4.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static fsync fsync(MemorySegment segment, Arena scope) {
-        return fsync.ofAddress(fsync$get(segment), scope);
+    public static void chown(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(chown$LAYOUT, chown$OFFSET, fieldValue);
     }
+
     /**
-     * {@snippet :
- * int (*setxattr)(char*,char*,char*,unsigned long,int);
+     * {@snippet lang=c :
+     * int (*truncate)(const char *, off_t, struct fuse_file_info *)
      * }
      */
-    public interface setxattr {
+    public static class truncate {
+
+        truncate() {
+            // Should not be called directly
+        }
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, long _x1, MemorySegment _x2);
+        }
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_LONG,
+            fuse_h.C_POINTER
+        );
 
-        int apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1, java.lang.foreign.MemorySegment _x2, long _x3, int _x4);
-        static MemorySegment allocate(setxattr fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$24.const$5, fi, constants$9.const$5, scope);
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
         }
-        static setxattr ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1, java.lang.foreign.MemorySegment __x2, long __x3, int __x4) -> {
-                try {
-                    return (int)constants$10.const$1.invokeExact(symbol, __x0, __x1, __x2, __x3, __x4);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(truncate.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(truncate.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, long _x1, MemorySegment _x2) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
         }
     }
 
-    public static VarHandle setxattr$VH() {
-        return constants$25.const$0;
+    private static final AddressLayout truncate$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("truncate"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*truncate)(const char *, off_t, struct fuse_file_info *)
+     * }
+     */
+    public static final AddressLayout truncate$layout() {
+        return truncate$LAYOUT;
+    }
+
+    private static final long truncate$OFFSET = 88;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*truncate)(const char *, off_t, struct fuse_file_info *)
+     * }
+     */
+    public static final long truncate$offset() {
+        return truncate$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int (*setxattr)(char*,char*,char*,unsigned long,int);
+     * {@snippet lang=c :
+     * int (*truncate)(const char *, off_t, struct fuse_file_info *)
      * }
      */
-    public static MemorySegment setxattr$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$25.const$0.get(seg);
+    public static MemorySegment truncate(MemorySegment struct) {
+        return struct.get(truncate$LAYOUT, truncate$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int (*setxattr)(char*,char*,char*,unsigned long,int);
+     * {@snippet lang=c :
+     * int (*truncate)(const char *, off_t, struct fuse_file_info *)
      * }
      */
-    public static void setxattr$set(MemorySegment seg, MemorySegment x) {
-        constants$25.const$0.set(seg, x);
-    }
-    public static MemorySegment setxattr$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$25.const$0.get(seg.asSlice(index*sizeof()));
-    }
-    public static void setxattr$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$25.const$0.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static setxattr setxattr(MemorySegment segment, Arena scope) {
-        return setxattr.ofAddress(setxattr$get(segment), scope);
+    public static void truncate(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(truncate$LAYOUT, truncate$OFFSET, fieldValue);
     }
+
     /**
-     * {@snippet :
- * int (*getxattr)(char*,char*,char*,unsigned long);
+     * {@snippet lang=c :
+     * int (*open)(const char *, struct fuse_file_info *)
      * }
      */
-    public interface getxattr {
+    public static class open {
+
+        open() {
+            // Should not be called directly
+        }
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, MemorySegment _x1);
+        }
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
 
-        int apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1, java.lang.foreign.MemorySegment _x2, long _x3);
-        static MemorySegment allocate(getxattr fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$25.const$2, fi, constants$25.const$1, scope);
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(open.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(open.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
         }
-        static getxattr ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1, java.lang.foreign.MemorySegment __x2, long __x3) -> {
-                try {
-                    return (int)constants$25.const$3.invokeExact(symbol, __x0, __x1, __x2, __x3);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
         }
     }
 
-    public static VarHandle getxattr$VH() {
-        return constants$25.const$4;
+    private static final AddressLayout open$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("open"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*open)(const char *, struct fuse_file_info *)
+     * }
+     */
+    public static final AddressLayout open$layout() {
+        return open$LAYOUT;
+    }
+
+    private static final long open$OFFSET = 96;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*open)(const char *, struct fuse_file_info *)
+     * }
+     */
+    public static final long open$offset() {
+        return open$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int (*getxattr)(char*,char*,char*,unsigned long);
+     * {@snippet lang=c :
+     * int (*open)(const char *, struct fuse_file_info *)
      * }
      */
-    public static MemorySegment getxattr$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$25.const$4.get(seg);
+    public static MemorySegment open(MemorySegment struct) {
+        return struct.get(open$LAYOUT, open$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int (*getxattr)(char*,char*,char*,unsigned long);
+     * {@snippet lang=c :
+     * int (*open)(const char *, struct fuse_file_info *)
      * }
      */
-    public static void getxattr$set(MemorySegment seg, MemorySegment x) {
-        constants$25.const$4.set(seg, x);
-    }
-    public static MemorySegment getxattr$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$25.const$4.get(seg.asSlice(index*sizeof()));
-    }
-    public static void getxattr$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$25.const$4.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static getxattr getxattr(MemorySegment segment, Arena scope) {
-        return getxattr.ofAddress(getxattr$get(segment), scope);
+    public static void open(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(open$LAYOUT, open$OFFSET, fieldValue);
     }
+
     /**
-     * {@snippet :
- * int (*listxattr)(char*,char*,unsigned long);
+     * {@snippet lang=c :
+     * int (*read)(const char *, char *, size_t, off_t, struct fuse_file_info *)
      * }
      */
-    public interface listxattr {
+    public static class read {
+
+        read() {
+            // Should not be called directly
+        }
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, MemorySegment _x1, long _x2, long _x3, MemorySegment _x4);
+        }
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER,
+            fuse_h.C_LONG,
+            fuse_h.C_LONG,
+            fuse_h.C_POINTER
+        );
 
-        int apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1, long _x2);
-        static MemorySegment allocate(listxattr fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$25.const$5, fi, constants$15.const$3, scope);
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
         }
-        static listxattr ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1, long __x2) -> {
-                try {
-                    return (int)constants$15.const$5.invokeExact(symbol, __x0, __x1, __x2);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(read.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(read.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1, long _x2, long _x3, MemorySegment _x4) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2, _x3, _x4);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
         }
     }
 
-    public static VarHandle listxattr$VH() {
-        return constants$26.const$0;
+    private static final AddressLayout read$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("read"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*read)(const char *, char *, size_t, off_t, struct fuse_file_info *)
+     * }
+     */
+    public static final AddressLayout read$layout() {
+        return read$LAYOUT;
+    }
+
+    private static final long read$OFFSET = 104;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*read)(const char *, char *, size_t, off_t, struct fuse_file_info *)
+     * }
+     */
+    public static final long read$offset() {
+        return read$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int (*listxattr)(char*,char*,unsigned long);
+     * {@snippet lang=c :
+     * int (*read)(const char *, char *, size_t, off_t, struct fuse_file_info *)
      * }
      */
-    public static MemorySegment listxattr$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$26.const$0.get(seg);
+    public static MemorySegment read(MemorySegment struct) {
+        return struct.get(read$LAYOUT, read$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int (*listxattr)(char*,char*,unsigned long);
+     * {@snippet lang=c :
+     * int (*read)(const char *, char *, size_t, off_t, struct fuse_file_info *)
      * }
      */
-    public static void listxattr$set(MemorySegment seg, MemorySegment x) {
-        constants$26.const$0.set(seg, x);
-    }
-    public static MemorySegment listxattr$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$26.const$0.get(seg.asSlice(index*sizeof()));
-    }
-    public static void listxattr$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$26.const$0.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static listxattr listxattr(MemorySegment segment, Arena scope) {
-        return listxattr.ofAddress(listxattr$get(segment), scope);
+    public static void read(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(read$LAYOUT, read$OFFSET, fieldValue);
     }
+
     /**
-     * {@snippet :
- * int (*removexattr)(char*,char*);
+     * {@snippet lang=c :
+     * int (*write)(const char *, const char *, size_t, off_t, struct fuse_file_info *)
      * }
      */
-    public interface removexattr {
+    public static class write {
+
+        write() {
+            // Should not be called directly
+        }
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, MemorySegment _x1, long _x2, long _x3, MemorySegment _x4);
+        }
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER,
+            fuse_h.C_LONG,
+            fuse_h.C_LONG,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
 
-        int apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1);
-        static MemorySegment allocate(removexattr fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$26.const$1, fi, constants$18.const$3, scope);
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(write.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(write.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
         }
-        static removexattr ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1) -> {
-                try {
-                    return (int)constants$18.const$5.invokeExact(symbol, __x0, __x1);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1, long _x2, long _x3, MemorySegment _x4) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2, _x3, _x4);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
         }
     }
 
-    public static VarHandle removexattr$VH() {
-        return constants$26.const$2;
+    private static final AddressLayout write$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("write"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*write)(const char *, const char *, size_t, off_t, struct fuse_file_info *)
+     * }
+     */
+    public static final AddressLayout write$layout() {
+        return write$LAYOUT;
+    }
+
+    private static final long write$OFFSET = 112;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*write)(const char *, const char *, size_t, off_t, struct fuse_file_info *)
+     * }
+     */
+    public static final long write$offset() {
+        return write$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int (*removexattr)(char*,char*);
+     * {@snippet lang=c :
+     * int (*write)(const char *, const char *, size_t, off_t, struct fuse_file_info *)
      * }
      */
-    public static MemorySegment removexattr$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$26.const$2.get(seg);
+    public static MemorySegment write(MemorySegment struct) {
+        return struct.get(write$LAYOUT, write$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int (*removexattr)(char*,char*);
+     * {@snippet lang=c :
+     * int (*write)(const char *, const char *, size_t, off_t, struct fuse_file_info *)
      * }
      */
-    public static void removexattr$set(MemorySegment seg, MemorySegment x) {
-        constants$26.const$2.set(seg, x);
-    }
-    public static MemorySegment removexattr$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$26.const$2.get(seg.asSlice(index*sizeof()));
-    }
-    public static void removexattr$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$26.const$2.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static removexattr removexattr(MemorySegment segment, Arena scope) {
-        return removexattr.ofAddress(removexattr$get(segment), scope);
+    public static void write(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(write$LAYOUT, write$OFFSET, fieldValue);
     }
+
     /**
-     * {@snippet :
- * int (*opendir)(char*,struct fuse_file_info*);
+     * {@snippet lang=c :
+     * int (*statfs)(const char *, struct statvfs *)
      * }
      */
-    public interface opendir {
+    public static class statfs {
+
+        statfs() {
+            // Should not be called directly
+        }
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, MemorySegment _x1);
+        }
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER
+        );
 
-        int apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1);
-        static MemorySegment allocate(opendir fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$26.const$3, fi, constants$18.const$3, scope);
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
         }
-        static opendir ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1) -> {
-                try {
-                    return (int)constants$18.const$5.invokeExact(symbol, __x0, __x1);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(statfs.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(statfs.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
         }
     }
 
-    public static VarHandle opendir$VH() {
-        return constants$26.const$4;
+    private static final AddressLayout statfs$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("statfs"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*statfs)(const char *, struct statvfs *)
+     * }
+     */
+    public static final AddressLayout statfs$layout() {
+        return statfs$LAYOUT;
+    }
+
+    private static final long statfs$OFFSET = 120;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*statfs)(const char *, struct statvfs *)
+     * }
+     */
+    public static final long statfs$offset() {
+        return statfs$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int (*opendir)(char*,struct fuse_file_info*);
+     * {@snippet lang=c :
+     * int (*statfs)(const char *, struct statvfs *)
      * }
      */
-    public static MemorySegment opendir$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$26.const$4.get(seg);
+    public static MemorySegment statfs(MemorySegment struct) {
+        return struct.get(statfs$LAYOUT, statfs$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int (*opendir)(char*,struct fuse_file_info*);
+     * {@snippet lang=c :
+     * int (*statfs)(const char *, struct statvfs *)
      * }
      */
-    public static void opendir$set(MemorySegment seg, MemorySegment x) {
-        constants$26.const$4.set(seg, x);
-    }
-    public static MemorySegment opendir$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$26.const$4.get(seg.asSlice(index*sizeof()));
-    }
-    public static void opendir$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$26.const$4.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static opendir opendir(MemorySegment segment, Arena scope) {
-        return opendir.ofAddress(opendir$get(segment), scope);
+    public static void statfs(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(statfs$LAYOUT, statfs$OFFSET, fieldValue);
     }
+
     /**
-     * {@snippet :
- * int (*readdir)(char*,void*,int (*)(void*,char*,struct stat*,long,enum fuse_fill_dir_flags),long,struct fuse_file_info*,enum fuse_readdir_flags);
+     * {@snippet lang=c :
+     * int (*flush)(const char *, struct fuse_file_info *)
      * }
      */
-    public interface readdir {
+    public static class flush {
 
-        int apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1, java.lang.foreign.MemorySegment _x2, long _x3, java.lang.foreign.MemorySegment _x4, int _x5);
-        static MemorySegment allocate(readdir fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$27.const$0, fi, constants$26.const$5, scope);
+        flush() {
+            // Should not be called directly
         }
-        static readdir ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1, java.lang.foreign.MemorySegment __x2, long __x3, java.lang.foreign.MemorySegment __x4, int __x5) -> {
-                try {
-                    return (int)constants$27.const$1.invokeExact(symbol, __x0, __x1, __x2, __x3, __x4, __x5);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, MemorySegment _x1);
         }
-    }
 
-    public static VarHandle readdir$VH() {
-        return constants$27.const$2;
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(flush.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(flush.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
     }
+
+    private static final AddressLayout flush$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("flush"));
+
     /**
-     * Getter for field:
-     * {@snippet :
-     * int (*readdir)(char*,void*,int (*)(void*,char*,struct stat*,long,enum fuse_fill_dir_flags),long,struct fuse_file_info*,enum fuse_readdir_flags);
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*flush)(const char *, struct fuse_file_info *)
      * }
      */
-    public static MemorySegment readdir$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$27.const$2.get(seg);
+    public static final AddressLayout flush$layout() {
+        return flush$LAYOUT;
     }
+
+    private static final long flush$OFFSET = 128;
+
     /**
-     * Setter for field:
-     * {@snippet :
-     * int (*readdir)(char*,void*,int (*)(void*,char*,struct stat*,long,enum fuse_fill_dir_flags),long,struct fuse_file_info*,enum fuse_readdir_flags);
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*flush)(const char *, struct fuse_file_info *)
      * }
      */
-    public static void readdir$set(MemorySegment seg, MemorySegment x) {
-        constants$27.const$2.set(seg, x);
-    }
-    public static MemorySegment readdir$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$27.const$2.get(seg.asSlice(index*sizeof()));
-    }
-    public static void readdir$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$27.const$2.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static readdir readdir(MemorySegment segment, Arena scope) {
-        return readdir.ofAddress(readdir$get(segment), scope);
+    public static final long flush$offset() {
+        return flush$OFFSET;
     }
+
     /**
-     * {@snippet :
- * int (*releasedir)(char*,struct fuse_file_info*);
+     * Getter for field:
+     * {@snippet lang=c :
+     * int (*flush)(const char *, struct fuse_file_info *)
      * }
      */
-    public interface releasedir {
-
-        int apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1);
-        static MemorySegment allocate(releasedir fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$27.const$3, fi, constants$18.const$3, scope);
-        }
-        static releasedir ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1) -> {
-                try {
-                    return (int)constants$18.const$5.invokeExact(symbol, __x0, __x1);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
-        }
+    public static MemorySegment flush(MemorySegment struct) {
+        return struct.get(flush$LAYOUT, flush$OFFSET);
     }
 
-    public static VarHandle releasedir$VH() {
-        return constants$27.const$4;
-    }
     /**
-     * Getter for field:
-     * {@snippet :
-     * int (*releasedir)(char*,struct fuse_file_info*);
+     * Setter for field:
+     * {@snippet lang=c :
+     * int (*flush)(const char *, struct fuse_file_info *)
      * }
      */
-    public static MemorySegment releasedir$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$27.const$4.get(seg);
+    public static void flush(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(flush$LAYOUT, flush$OFFSET, fieldValue);
     }
+
     /**
-     * Setter for field:
-     * {@snippet :
-     * int (*releasedir)(char*,struct fuse_file_info*);
+     * {@snippet lang=c :
+     * int (*release)(const char *, struct fuse_file_info *)
      * }
      */
-    public static void releasedir$set(MemorySegment seg, MemorySegment x) {
-        constants$27.const$4.set(seg, x);
-    }
-    public static MemorySegment releasedir$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$27.const$4.get(seg.asSlice(index*sizeof()));
-    }
-    public static void releasedir$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$27.const$4.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static releasedir releasedir(MemorySegment segment, Arena scope) {
-        return releasedir.ofAddress(releasedir$get(segment), scope);
+    public static class release {
+
+        release() {
+            // Should not be called directly
+        }
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, MemorySegment _x1);
+        }
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(release.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(release.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
+    }
+
+    private static final AddressLayout release$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("release"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*release)(const char *, struct fuse_file_info *)
+     * }
+     */
+    public static final AddressLayout release$layout() {
+        return release$LAYOUT;
+    }
+
+    private static final long release$OFFSET = 136;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*release)(const char *, struct fuse_file_info *)
+     * }
+     */
+    public static final long release$offset() {
+        return release$OFFSET;
+    }
+
+    /**
+     * Getter for field:
+     * {@snippet lang=c :
+     * int (*release)(const char *, struct fuse_file_info *)
+     * }
+     */
+    public static MemorySegment release(MemorySegment struct) {
+        return struct.get(release$LAYOUT, release$OFFSET);
+    }
+
+    /**
+     * Setter for field:
+     * {@snippet lang=c :
+     * int (*release)(const char *, struct fuse_file_info *)
+     * }
+     */
+    public static void release(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(release$LAYOUT, release$OFFSET, fieldValue);
+    }
+
+    /**
+     * {@snippet lang=c :
+     * int (*fsync)(const char *, int, struct fuse_file_info *)
+     * }
+     */
+    public static class fsync {
+
+        fsync() {
+            // Should not be called directly
+        }
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, int _x1, MemorySegment _x2);
+        }
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_INT,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(fsync.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(fsync.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, int _x1, MemorySegment _x2) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
+    }
+
+    private static final AddressLayout fsync$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("fsync"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*fsync)(const char *, int, struct fuse_file_info *)
+     * }
+     */
+    public static final AddressLayout fsync$layout() {
+        return fsync$LAYOUT;
+    }
+
+    private static final long fsync$OFFSET = 144;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*fsync)(const char *, int, struct fuse_file_info *)
+     * }
+     */
+    public static final long fsync$offset() {
+        return fsync$OFFSET;
+    }
+
+    /**
+     * Getter for field:
+     * {@snippet lang=c :
+     * int (*fsync)(const char *, int, struct fuse_file_info *)
+     * }
+     */
+    public static MemorySegment fsync(MemorySegment struct) {
+        return struct.get(fsync$LAYOUT, fsync$OFFSET);
+    }
+
+    /**
+     * Setter for field:
+     * {@snippet lang=c :
+     * int (*fsync)(const char *, int, struct fuse_file_info *)
+     * }
+     */
+    public static void fsync(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(fsync$LAYOUT, fsync$OFFSET, fieldValue);
+    }
+
+    /**
+     * {@snippet lang=c :
+     * int (*setxattr)(const char *, const char *, const char *, size_t, int)
+     * }
+     */
+    public static class setxattr {
+
+        setxattr() {
+            // Should not be called directly
+        }
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, MemorySegment _x1, MemorySegment _x2, long _x3, int _x4);
+        }
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER,
+            fuse_h.C_LONG,
+            fuse_h.C_INT
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(setxattr.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(setxattr.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1, MemorySegment _x2, long _x3, int _x4) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2, _x3, _x4);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
+    }
+
+    private static final AddressLayout setxattr$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("setxattr"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*setxattr)(const char *, const char *, const char *, size_t, int)
+     * }
+     */
+    public static final AddressLayout setxattr$layout() {
+        return setxattr$LAYOUT;
+    }
+
+    private static final long setxattr$OFFSET = 152;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*setxattr)(const char *, const char *, const char *, size_t, int)
+     * }
+     */
+    public static final long setxattr$offset() {
+        return setxattr$OFFSET;
+    }
+
+    /**
+     * Getter for field:
+     * {@snippet lang=c :
+     * int (*setxattr)(const char *, const char *, const char *, size_t, int)
+     * }
+     */
+    public static MemorySegment setxattr(MemorySegment struct) {
+        return struct.get(setxattr$LAYOUT, setxattr$OFFSET);
+    }
+
+    /**
+     * Setter for field:
+     * {@snippet lang=c :
+     * int (*setxattr)(const char *, const char *, const char *, size_t, int)
+     * }
+     */
+    public static void setxattr(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(setxattr$LAYOUT, setxattr$OFFSET, fieldValue);
+    }
+
+    /**
+     * {@snippet lang=c :
+     * int (*getxattr)(const char *, const char *, char *, size_t)
+     * }
+     */
+    public static class getxattr {
+
+        getxattr() {
+            // Should not be called directly
+        }
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, MemorySegment _x1, MemorySegment _x2, long _x3);
+        }
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER,
+            fuse_h.C_LONG
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(getxattr.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(getxattr.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1, MemorySegment _x2, long _x3) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2, _x3);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
+    }
+
+    private static final AddressLayout getxattr$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("getxattr"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*getxattr)(const char *, const char *, char *, size_t)
+     * }
+     */
+    public static final AddressLayout getxattr$layout() {
+        return getxattr$LAYOUT;
+    }
+
+    private static final long getxattr$OFFSET = 160;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*getxattr)(const char *, const char *, char *, size_t)
+     * }
+     */
+    public static final long getxattr$offset() {
+        return getxattr$OFFSET;
+    }
+
+    /**
+     * Getter for field:
+     * {@snippet lang=c :
+     * int (*getxattr)(const char *, const char *, char *, size_t)
+     * }
+     */
+    public static MemorySegment getxattr(MemorySegment struct) {
+        return struct.get(getxattr$LAYOUT, getxattr$OFFSET);
+    }
+
+    /**
+     * Setter for field:
+     * {@snippet lang=c :
+     * int (*getxattr)(const char *, const char *, char *, size_t)
+     * }
+     */
+    public static void getxattr(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(getxattr$LAYOUT, getxattr$OFFSET, fieldValue);
+    }
+
+    /**
+     * {@snippet lang=c :
+     * int (*listxattr)(const char *, char *, size_t)
+     * }
+     */
+    public static class listxattr {
+
+        listxattr() {
+            // Should not be called directly
+        }
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, MemorySegment _x1, long _x2);
+        }
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER,
+            fuse_h.C_LONG
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(listxattr.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(listxattr.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1, long _x2) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
+    }
+
+    private static final AddressLayout listxattr$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("listxattr"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*listxattr)(const char *, char *, size_t)
+     * }
+     */
+    public static final AddressLayout listxattr$layout() {
+        return listxattr$LAYOUT;
+    }
+
+    private static final long listxattr$OFFSET = 168;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*listxattr)(const char *, char *, size_t)
+     * }
+     */
+    public static final long listxattr$offset() {
+        return listxattr$OFFSET;
+    }
+
+    /**
+     * Getter for field:
+     * {@snippet lang=c :
+     * int (*listxattr)(const char *, char *, size_t)
+     * }
+     */
+    public static MemorySegment listxattr(MemorySegment struct) {
+        return struct.get(listxattr$LAYOUT, listxattr$OFFSET);
+    }
+
+    /**
+     * Setter for field:
+     * {@snippet lang=c :
+     * int (*listxattr)(const char *, char *, size_t)
+     * }
+     */
+    public static void listxattr(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(listxattr$LAYOUT, listxattr$OFFSET, fieldValue);
+    }
+
+    /**
+     * {@snippet lang=c :
+     * int (*removexattr)(const char *, const char *)
+     * }
+     */
+    public static class removexattr {
+
+        removexattr() {
+            // Should not be called directly
+        }
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, MemorySegment _x1);
+        }
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(removexattr.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(removexattr.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
+    }
+
+    private static final AddressLayout removexattr$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("removexattr"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*removexattr)(const char *, const char *)
+     * }
+     */
+    public static final AddressLayout removexattr$layout() {
+        return removexattr$LAYOUT;
+    }
+
+    private static final long removexattr$OFFSET = 176;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*removexattr)(const char *, const char *)
+     * }
+     */
+    public static final long removexattr$offset() {
+        return removexattr$OFFSET;
+    }
+
+    /**
+     * Getter for field:
+     * {@snippet lang=c :
+     * int (*removexattr)(const char *, const char *)
+     * }
+     */
+    public static MemorySegment removexattr(MemorySegment struct) {
+        return struct.get(removexattr$LAYOUT, removexattr$OFFSET);
+    }
+
+    /**
+     * Setter for field:
+     * {@snippet lang=c :
+     * int (*removexattr)(const char *, const char *)
+     * }
+     */
+    public static void removexattr(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(removexattr$LAYOUT, removexattr$OFFSET, fieldValue);
+    }
+
+    /**
+     * {@snippet lang=c :
+     * int (*opendir)(const char *, struct fuse_file_info *)
+     * }
+     */
+    public static class opendir {
+
+        opendir() {
+            // Should not be called directly
+        }
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, MemorySegment _x1);
+        }
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(opendir.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(opendir.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
+    }
+
+    private static final AddressLayout opendir$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("opendir"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*opendir)(const char *, struct fuse_file_info *)
+     * }
+     */
+    public static final AddressLayout opendir$layout() {
+        return opendir$LAYOUT;
+    }
+
+    private static final long opendir$OFFSET = 184;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*opendir)(const char *, struct fuse_file_info *)
+     * }
+     */
+    public static final long opendir$offset() {
+        return opendir$OFFSET;
+    }
+
+    /**
+     * Getter for field:
+     * {@snippet lang=c :
+     * int (*opendir)(const char *, struct fuse_file_info *)
+     * }
+     */
+    public static MemorySegment opendir(MemorySegment struct) {
+        return struct.get(opendir$LAYOUT, opendir$OFFSET);
+    }
+
+    /**
+     * Setter for field:
+     * {@snippet lang=c :
+     * int (*opendir)(const char *, struct fuse_file_info *)
+     * }
+     */
+    public static void opendir(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(opendir$LAYOUT, opendir$OFFSET, fieldValue);
+    }
+
+    /**
+     * {@snippet lang=c :
+     * int (*readdir)(const char *, void *, fuse_fill_dir_t, off_t, struct fuse_file_info *, enum fuse_readdir_flags)
+     * }
+     */
+    public static class readdir {
+
+        readdir() {
+            // Should not be called directly
+        }
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, MemorySegment _x1, MemorySegment _x2, long _x3, MemorySegment _x4, int _x5);
+        }
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER,
+            fuse_h.C_LONG,
+            fuse_h.C_POINTER,
+            fuse_h.C_INT
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(readdir.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(readdir.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1, MemorySegment _x2, long _x3, MemorySegment _x4, int _x5) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2, _x3, _x4, _x5);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
+    }
+
+    private static final AddressLayout readdir$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("readdir"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*readdir)(const char *, void *, fuse_fill_dir_t, off_t, struct fuse_file_info *, enum fuse_readdir_flags)
+     * }
+     */
+    public static final AddressLayout readdir$layout() {
+        return readdir$LAYOUT;
+    }
+
+    private static final long readdir$OFFSET = 192;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*readdir)(const char *, void *, fuse_fill_dir_t, off_t, struct fuse_file_info *, enum fuse_readdir_flags)
+     * }
+     */
+    public static final long readdir$offset() {
+        return readdir$OFFSET;
+    }
+
+    /**
+     * Getter for field:
+     * {@snippet lang=c :
+     * int (*readdir)(const char *, void *, fuse_fill_dir_t, off_t, struct fuse_file_info *, enum fuse_readdir_flags)
+     * }
+     */
+    public static MemorySegment readdir(MemorySegment struct) {
+        return struct.get(readdir$LAYOUT, readdir$OFFSET);
+    }
+
+    /**
+     * Setter for field:
+     * {@snippet lang=c :
+     * int (*readdir)(const char *, void *, fuse_fill_dir_t, off_t, struct fuse_file_info *, enum fuse_readdir_flags)
+     * }
+     */
+    public static void readdir(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(readdir$LAYOUT, readdir$OFFSET, fieldValue);
+    }
+
+    /**
+     * {@snippet lang=c :
+     * int (*releasedir)(const char *, struct fuse_file_info *)
+     * }
+     */
+    public static class releasedir {
+
+        releasedir() {
+            // Should not be called directly
+        }
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, MemorySegment _x1);
+        }
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(releasedir.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(releasedir.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
+    }
+
+    private static final AddressLayout releasedir$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("releasedir"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*releasedir)(const char *, struct fuse_file_info *)
+     * }
+     */
+    public static final AddressLayout releasedir$layout() {
+        return releasedir$LAYOUT;
+    }
+
+    private static final long releasedir$OFFSET = 200;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*releasedir)(const char *, struct fuse_file_info *)
+     * }
+     */
+    public static final long releasedir$offset() {
+        return releasedir$OFFSET;
+    }
+
+    /**
+     * Getter for field:
+     * {@snippet lang=c :
+     * int (*releasedir)(const char *, struct fuse_file_info *)
+     * }
+     */
+    public static MemorySegment releasedir(MemorySegment struct) {
+        return struct.get(releasedir$LAYOUT, releasedir$OFFSET);
+    }
+
+    /**
+     * Setter for field:
+     * {@snippet lang=c :
+     * int (*releasedir)(const char *, struct fuse_file_info *)
+     * }
+     */
+    public static void releasedir(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(releasedir$LAYOUT, releasedir$OFFSET, fieldValue);
+    }
+
+    /**
+     * {@snippet lang=c :
+     * int (*fsyncdir)(const char *, int, struct fuse_file_info *)
+     * }
+     */
+    public static class fsyncdir {
+
+        fsyncdir() {
+            // Should not be called directly
+        }
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, int _x1, MemorySegment _x2);
+        }
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_INT,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(fsyncdir.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(fsyncdir.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, int _x1, MemorySegment _x2) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
+    }
+
+    private static final AddressLayout fsyncdir$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("fsyncdir"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*fsyncdir)(const char *, int, struct fuse_file_info *)
+     * }
+     */
+    public static final AddressLayout fsyncdir$layout() {
+        return fsyncdir$LAYOUT;
+    }
+
+    private static final long fsyncdir$OFFSET = 208;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*fsyncdir)(const char *, int, struct fuse_file_info *)
+     * }
+     */
+    public static final long fsyncdir$offset() {
+        return fsyncdir$OFFSET;
+    }
+
+    /**
+     * Getter for field:
+     * {@snippet lang=c :
+     * int (*fsyncdir)(const char *, int, struct fuse_file_info *)
+     * }
+     */
+    public static MemorySegment fsyncdir(MemorySegment struct) {
+        return struct.get(fsyncdir$LAYOUT, fsyncdir$OFFSET);
+    }
+
+    /**
+     * Setter for field:
+     * {@snippet lang=c :
+     * int (*fsyncdir)(const char *, int, struct fuse_file_info *)
+     * }
+     */
+    public static void fsyncdir(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(fsyncdir$LAYOUT, fsyncdir$OFFSET, fieldValue);
+    }
+
+    /**
+     * {@snippet lang=c :
+     * void *(*init)(struct fuse_conn_info *, struct fuse_config *)
+     * }
+     */
+    public static class init {
+
+        init() {
+            // Should not be called directly
+        }
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            MemorySegment apply(MemorySegment _x0, MemorySegment _x1);
+        }
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(init.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(init.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static MemorySegment invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1) {
+            try {
+                return (MemorySegment) DOWN$MH.invokeExact(funcPtr, _x0, _x1);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
+    }
+
+    private static final AddressLayout init$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("init"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * void *(*init)(struct fuse_conn_info *, struct fuse_config *)
+     * }
+     */
+    public static final AddressLayout init$layout() {
+        return init$LAYOUT;
+    }
+
+    private static final long init$OFFSET = 216;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * void *(*init)(struct fuse_conn_info *, struct fuse_config *)
+     * }
+     */
+    public static final long init$offset() {
+        return init$OFFSET;
+    }
+
+    /**
+     * Getter for field:
+     * {@snippet lang=c :
+     * void *(*init)(struct fuse_conn_info *, struct fuse_config *)
+     * }
+     */
+    public static MemorySegment init(MemorySegment struct) {
+        return struct.get(init$LAYOUT, init$OFFSET);
+    }
+
+    /**
+     * Setter for field:
+     * {@snippet lang=c :
+     * void *(*init)(struct fuse_conn_info *, struct fuse_config *)
+     * }
+     */
+    public static void init(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(init$LAYOUT, init$OFFSET, fieldValue);
+    }
+
+    /**
+     * {@snippet lang=c :
+     * void (*destroy)(void *)
+     * }
+     */
+    public static class destroy {
+
+        destroy() {
+            // Should not be called directly
+        }
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            void apply(MemorySegment _x0);
+        }
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.ofVoid(
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(destroy.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(destroy.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static void invoke(MemorySegment funcPtr,MemorySegment _x0) {
+            try {
+                 DOWN$MH.invokeExact(funcPtr, _x0);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
+    }
+
+    private static final AddressLayout destroy$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("destroy"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * void (*destroy)(void *)
+     * }
+     */
+    public static final AddressLayout destroy$layout() {
+        return destroy$LAYOUT;
+    }
+
+    private static final long destroy$OFFSET = 224;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * void (*destroy)(void *)
+     * }
+     */
+    public static final long destroy$offset() {
+        return destroy$OFFSET;
+    }
+
+    /**
+     * Getter for field:
+     * {@snippet lang=c :
+     * void (*destroy)(void *)
+     * }
+     */
+    public static MemorySegment destroy(MemorySegment struct) {
+        return struct.get(destroy$LAYOUT, destroy$OFFSET);
+    }
+
+    /**
+     * Setter for field:
+     * {@snippet lang=c :
+     * void (*destroy)(void *)
+     * }
+     */
+    public static void destroy(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(destroy$LAYOUT, destroy$OFFSET, fieldValue);
+    }
+
+    /**
+     * {@snippet lang=c :
+     * int (*access)(const char *, int)
+     * }
+     */
+    public static class access {
+
+        access() {
+            // Should not be called directly
+        }
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, int _x1);
+        }
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_INT
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(access.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(access.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, int _x1) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
+    }
+
+    private static final AddressLayout access$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("access"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*access)(const char *, int)
+     * }
+     */
+    public static final AddressLayout access$layout() {
+        return access$LAYOUT;
+    }
+
+    private static final long access$OFFSET = 232;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*access)(const char *, int)
+     * }
+     */
+    public static final long access$offset() {
+        return access$OFFSET;
+    }
+
+    /**
+     * Getter for field:
+     * {@snippet lang=c :
+     * int (*access)(const char *, int)
+     * }
+     */
+    public static MemorySegment access(MemorySegment struct) {
+        return struct.get(access$LAYOUT, access$OFFSET);
+    }
+
+    /**
+     * Setter for field:
+     * {@snippet lang=c :
+     * int (*access)(const char *, int)
+     * }
+     */
+    public static void access(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(access$LAYOUT, access$OFFSET, fieldValue);
+    }
+
+    /**
+     * {@snippet lang=c :
+     * int (*create)(const char *, mode_t, struct fuse_file_info *)
+     * }
+     */
+    public static class create {
+
+        create() {
+            // Should not be called directly
+        }
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, int _x1, MemorySegment _x2);
+        }
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_INT,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(create.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(create.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, int _x1, MemorySegment _x2) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
+    }
+
+    private static final AddressLayout create$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("create"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*create)(const char *, mode_t, struct fuse_file_info *)
+     * }
+     */
+    public static final AddressLayout create$layout() {
+        return create$LAYOUT;
+    }
+
+    private static final long create$OFFSET = 240;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*create)(const char *, mode_t, struct fuse_file_info *)
+     * }
+     */
+    public static final long create$offset() {
+        return create$OFFSET;
+    }
+
+    /**
+     * Getter for field:
+     * {@snippet lang=c :
+     * int (*create)(const char *, mode_t, struct fuse_file_info *)
+     * }
+     */
+    public static MemorySegment create(MemorySegment struct) {
+        return struct.get(create$LAYOUT, create$OFFSET);
+    }
+
+    /**
+     * Setter for field:
+     * {@snippet lang=c :
+     * int (*create)(const char *, mode_t, struct fuse_file_info *)
+     * }
+     */
+    public static void create(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(create$LAYOUT, create$OFFSET, fieldValue);
+    }
+
+    /**
+     * {@snippet lang=c :
+     * int (*lock)(const char *, struct fuse_file_info *, int, struct flock *)
+     * }
+     */
+    public static class lock {
+
+        lock() {
+            // Should not be called directly
+        }
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, MemorySegment _x1, int _x2, MemorySegment _x3);
+        }
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER,
+            fuse_h.C_INT,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(lock.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(lock.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1, int _x2, MemorySegment _x3) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2, _x3);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
+    }
+
+    private static final AddressLayout lock$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("lock"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*lock)(const char *, struct fuse_file_info *, int, struct flock *)
+     * }
+     */
+    public static final AddressLayout lock$layout() {
+        return lock$LAYOUT;
+    }
+
+    private static final long lock$OFFSET = 248;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*lock)(const char *, struct fuse_file_info *, int, struct flock *)
+     * }
+     */
+    public static final long lock$offset() {
+        return lock$OFFSET;
+    }
+
+    /**
+     * Getter for field:
+     * {@snippet lang=c :
+     * int (*lock)(const char *, struct fuse_file_info *, int, struct flock *)
+     * }
+     */
+    public static MemorySegment lock(MemorySegment struct) {
+        return struct.get(lock$LAYOUT, lock$OFFSET);
+    }
+
+    /**
+     * Setter for field:
+     * {@snippet lang=c :
+     * int (*lock)(const char *, struct fuse_file_info *, int, struct flock *)
+     * }
+     */
+    public static void lock(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(lock$LAYOUT, lock$OFFSET, fieldValue);
+    }
+
+    /**
+     * {@snippet lang=c :
+     * int (*utimens)(const char *, const struct timespec *, struct fuse_file_info *)
+     * }
+     */
+    public static class utimens {
+
+        utimens() {
+            // Should not be called directly
+        }
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, MemorySegment _x1, MemorySegment _x2);
+        }
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(utimens.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(utimens.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1, MemorySegment _x2) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
+    }
+
+    private static final AddressLayout utimens$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("utimens"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*utimens)(const char *, const struct timespec *, struct fuse_file_info *)
+     * }
+     */
+    public static final AddressLayout utimens$layout() {
+        return utimens$LAYOUT;
+    }
+
+    private static final long utimens$OFFSET = 256;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*utimens)(const char *, const struct timespec *, struct fuse_file_info *)
+     * }
+     */
+    public static final long utimens$offset() {
+        return utimens$OFFSET;
+    }
+
+    /**
+     * Getter for field:
+     * {@snippet lang=c :
+     * int (*utimens)(const char *, const struct timespec *, struct fuse_file_info *)
+     * }
+     */
+    public static MemorySegment utimens(MemorySegment struct) {
+        return struct.get(utimens$LAYOUT, utimens$OFFSET);
+    }
+
+    /**
+     * Setter for field:
+     * {@snippet lang=c :
+     * int (*utimens)(const char *, const struct timespec *, struct fuse_file_info *)
+     * }
+     */
+    public static void utimens(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(utimens$LAYOUT, utimens$OFFSET, fieldValue);
+    }
+
+    /**
+     * {@snippet lang=c :
+     * int (*bmap)(const char *, size_t, uint64_t *)
+     * }
+     */
+    public static class bmap {
+
+        bmap() {
+            // Should not be called directly
+        }
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, long _x1, MemorySegment _x2);
+        }
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_LONG,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(bmap.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(bmap.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, long _x1, MemorySegment _x2) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
+    }
+
+    private static final AddressLayout bmap$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("bmap"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*bmap)(const char *, size_t, uint64_t *)
+     * }
+     */
+    public static final AddressLayout bmap$layout() {
+        return bmap$LAYOUT;
+    }
+
+    private static final long bmap$OFFSET = 264;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*bmap)(const char *, size_t, uint64_t *)
+     * }
+     */
+    public static final long bmap$offset() {
+        return bmap$OFFSET;
+    }
+
+    /**
+     * Getter for field:
+     * {@snippet lang=c :
+     * int (*bmap)(const char *, size_t, uint64_t *)
+     * }
+     */
+    public static MemorySegment bmap(MemorySegment struct) {
+        return struct.get(bmap$LAYOUT, bmap$OFFSET);
+    }
+
+    /**
+     * Setter for field:
+     * {@snippet lang=c :
+     * int (*bmap)(const char *, size_t, uint64_t *)
+     * }
+     */
+    public static void bmap(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(bmap$LAYOUT, bmap$OFFSET, fieldValue);
+    }
+
+    /**
+     * {@snippet lang=c :
+     * int (*ioctl)(const char *, unsigned int, void *, struct fuse_file_info *, unsigned int, void *)
+     * }
+     */
+    public static class ioctl {
+
+        ioctl() {
+            // Should not be called directly
+        }
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, int _x1, MemorySegment _x2, MemorySegment _x3, int _x4, MemorySegment _x5);
+        }
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER,
+            fuse_h.C_INT,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(ioctl.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(ioctl.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, int _x1, MemorySegment _x2, MemorySegment _x3, int _x4, MemorySegment _x5) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2, _x3, _x4, _x5);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
+    }
+
+    private static final AddressLayout ioctl$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("ioctl"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*ioctl)(const char *, unsigned int, void *, struct fuse_file_info *, unsigned int, void *)
+     * }
+     */
+    public static final AddressLayout ioctl$layout() {
+        return ioctl$LAYOUT;
     }
+
+    private static final long ioctl$OFFSET = 272;
+
     /**
-     * {@snippet :
- * int (*fsyncdir)(char*,int,struct fuse_file_info*);
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*ioctl)(const char *, unsigned int, void *, struct fuse_file_info *, unsigned int, void *)
      * }
      */
-    public interface fsyncdir {
-
-        int apply(java.lang.foreign.MemorySegment _x0, int _x1, java.lang.foreign.MemorySegment _x2);
-        static MemorySegment allocate(fsyncdir fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$27.const$5, fi, constants$20.const$1, scope);
-        }
-        static fsyncdir ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, int __x1, java.lang.foreign.MemorySegment __x2) -> {
-                try {
-                    return (int)constants$20.const$3.invokeExact(symbol, __x0, __x1, __x2);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
-        }
+    public static final long ioctl$offset() {
+        return ioctl$OFFSET;
     }
 
-    public static VarHandle fsyncdir$VH() {
-        return constants$28.const$0;
-    }
     /**
      * Getter for field:
-     * {@snippet :
-     * int (*fsyncdir)(char*,int,struct fuse_file_info*);
+     * {@snippet lang=c :
+     * int (*ioctl)(const char *, unsigned int, void *, struct fuse_file_info *, unsigned int, void *)
      * }
      */
-    public static MemorySegment fsyncdir$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$28.const$0.get(seg);
+    public static MemorySegment ioctl(MemorySegment struct) {
+        return struct.get(ioctl$LAYOUT, ioctl$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int (*fsyncdir)(char*,int,struct fuse_file_info*);
+     * {@snippet lang=c :
+     * int (*ioctl)(const char *, unsigned int, void *, struct fuse_file_info *, unsigned int, void *)
      * }
      */
-    public static void fsyncdir$set(MemorySegment seg, MemorySegment x) {
-        constants$28.const$0.set(seg, x);
-    }
-    public static MemorySegment fsyncdir$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$28.const$0.get(seg.asSlice(index*sizeof()));
-    }
-    public static void fsyncdir$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$28.const$0.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static fsyncdir fsyncdir(MemorySegment segment, Arena scope) {
-        return fsyncdir.ofAddress(fsyncdir$get(segment), scope);
+    public static void ioctl(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(ioctl$LAYOUT, ioctl$OFFSET, fieldValue);
     }
+
     /**
-     * {@snippet :
- * void* (*init)(struct fuse_conn_info*,struct fuse_config*);
+     * {@snippet lang=c :
+     * int (*poll)(const char *, struct fuse_file_info *, struct fuse_pollhandle *, unsigned int *)
      * }
      */
-    public interface init {
+    public static class poll {
 
-        java.lang.foreign.MemorySegment apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1);
-        static MemorySegment allocate(init fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$28.const$2, fi, constants$28.const$1, scope);
+        poll() {
+            // Should not be called directly
         }
-        static init ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1) -> {
-                try {
-                    return (java.lang.foreign.MemorySegment)constants$28.const$3.invokeExact(symbol, __x0, __x1);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, MemorySegment _x1, MemorySegment _x2, MemorySegment _x3);
         }
-    }
 
-    public static VarHandle init$VH() {
-        return constants$28.const$4;
-    }
-    /**
-     * Getter for field:
-     * {@snippet :
-     * void* (*init)(struct fuse_conn_info*,struct fuse_config*);
-     * }
-     */
-    public static MemorySegment init$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$28.const$4.get(seg);
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(poll.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(poll.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1, MemorySegment _x2, MemorySegment _x3) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2, _x3);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
     }
+
+    private static final AddressLayout poll$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("poll"));
+
     /**
-     * Setter for field:
-     * {@snippet :
-     * void* (*init)(struct fuse_conn_info*,struct fuse_config*);
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*poll)(const char *, struct fuse_file_info *, struct fuse_pollhandle *, unsigned int *)
      * }
      */
-    public static void init$set(MemorySegment seg, MemorySegment x) {
-        constants$28.const$4.set(seg, x);
-    }
-    public static MemorySegment init$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$28.const$4.get(seg.asSlice(index*sizeof()));
-    }
-    public static void init$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$28.const$4.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static init init(MemorySegment segment, Arena scope) {
-        return init.ofAddress(init$get(segment), scope);
+    public static final AddressLayout poll$layout() {
+        return poll$LAYOUT;
     }
+
+    private static final long poll$OFFSET = 280;
+
     /**
-     * {@snippet :
- * void (*destroy)(void*);
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*poll)(const char *, struct fuse_file_info *, struct fuse_pollhandle *, unsigned int *)
      * }
      */
-    public interface destroy {
-
-        void apply(java.lang.foreign.MemorySegment _x0);
-        static MemorySegment allocate(destroy fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$28.const$5, fi, constants$5.const$0, scope);
-        }
-        static destroy ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0) -> {
-                try {
-                    constants$29.const$0.invokeExact(symbol, __x0);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
-        }
+    public static final long poll$offset() {
+        return poll$OFFSET;
     }
 
-    public static VarHandle destroy$VH() {
-        return constants$29.const$1;
-    }
     /**
      * Getter for field:
-     * {@snippet :
-     * void (*destroy)(void*);
+     * {@snippet lang=c :
+     * int (*poll)(const char *, struct fuse_file_info *, struct fuse_pollhandle *, unsigned int *)
      * }
      */
-    public static MemorySegment destroy$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$29.const$1.get(seg);
+    public static MemorySegment poll(MemorySegment struct) {
+        return struct.get(poll$LAYOUT, poll$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * void (*destroy)(void*);
+     * {@snippet lang=c :
+     * int (*poll)(const char *, struct fuse_file_info *, struct fuse_pollhandle *, unsigned int *)
      * }
      */
-    public static void destroy$set(MemorySegment seg, MemorySegment x) {
-        constants$29.const$1.set(seg, x);
-    }
-    public static MemorySegment destroy$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$29.const$1.get(seg.asSlice(index*sizeof()));
-    }
-    public static void destroy$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$29.const$1.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static destroy destroy(MemorySegment segment, Arena scope) {
-        return destroy.ofAddress(destroy$get(segment), scope);
+    public static void poll(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(poll$LAYOUT, poll$OFFSET, fieldValue);
     }
+
     /**
-     * {@snippet :
- * int (*access)(char*,int);
+     * {@snippet lang=c :
+     * int (*write_buf)(const char *, struct fuse_bufvec *, off_t, struct fuse_file_info *)
      * }
      */
-    public interface access {
+    public static class write_buf {
 
-        int apply(java.lang.foreign.MemorySegment _x0, int _x1);
-        static MemorySegment allocate(access fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$29.const$2, fi, constants$16.const$5, scope);
+        write_buf() {
+            // Should not be called directly
         }
-        static access ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, int __x1) -> {
-                try {
-                    return (int)constants$17.const$1.invokeExact(symbol, __x0, __x1);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, MemorySegment _x1, long _x2, MemorySegment _x3);
         }
-    }
 
-    public static VarHandle access$VH() {
-        return constants$29.const$3;
-    }
-    /**
-     * Getter for field:
-     * {@snippet :
-     * int (*access)(char*,int);
-     * }
-     */
-    public static MemorySegment access$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$29.const$3.get(seg);
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER,
+            fuse_h.C_LONG,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(write_buf.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(write_buf.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1, long _x2, MemorySegment _x3) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2, _x3);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
     }
+
+    private static final AddressLayout write_buf$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("write_buf"));
+
     /**
-     * Setter for field:
-     * {@snippet :
-     * int (*access)(char*,int);
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*write_buf)(const char *, struct fuse_bufvec *, off_t, struct fuse_file_info *)
      * }
      */
-    public static void access$set(MemorySegment seg, MemorySegment x) {
-        constants$29.const$3.set(seg, x);
-    }
-    public static MemorySegment access$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$29.const$3.get(seg.asSlice(index*sizeof()));
-    }
-    public static void access$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$29.const$3.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static access access(MemorySegment segment, Arena scope) {
-        return access.ofAddress(access$get(segment), scope);
+    public static final AddressLayout write_buf$layout() {
+        return write_buf$LAYOUT;
     }
+
+    private static final long write_buf$OFFSET = 288;
+
     /**
-     * {@snippet :
- * int (*create)(char*,unsigned int,struct fuse_file_info*);
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*write_buf)(const char *, struct fuse_bufvec *, off_t, struct fuse_file_info *)
      * }
      */
-    public interface create {
-
-        int apply(java.lang.foreign.MemorySegment _x0, int _x1, java.lang.foreign.MemorySegment _x2);
-        static MemorySegment allocate(create fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$29.const$4, fi, constants$20.const$1, scope);
-        }
-        static create ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, int __x1, java.lang.foreign.MemorySegment __x2) -> {
-                try {
-                    return (int)constants$20.const$3.invokeExact(symbol, __x0, __x1, __x2);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
-        }
+    public static final long write_buf$offset() {
+        return write_buf$OFFSET;
     }
 
-    public static VarHandle create$VH() {
-        return constants$29.const$5;
-    }
     /**
      * Getter for field:
-     * {@snippet :
-     * int (*create)(char*,unsigned int,struct fuse_file_info*);
+     * {@snippet lang=c :
+     * int (*write_buf)(const char *, struct fuse_bufvec *, off_t, struct fuse_file_info *)
      * }
      */
-    public static MemorySegment create$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$29.const$5.get(seg);
+    public static MemorySegment write_buf(MemorySegment struct) {
+        return struct.get(write_buf$LAYOUT, write_buf$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int (*create)(char*,unsigned int,struct fuse_file_info*);
+     * {@snippet lang=c :
+     * int (*write_buf)(const char *, struct fuse_bufvec *, off_t, struct fuse_file_info *)
      * }
      */
-    public static void create$set(MemorySegment seg, MemorySegment x) {
-        constants$29.const$5.set(seg, x);
-    }
-    public static MemorySegment create$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$29.const$5.get(seg.asSlice(index*sizeof()));
-    }
-    public static void create$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$29.const$5.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static create create(MemorySegment segment, Arena scope) {
-        return create.ofAddress(create$get(segment), scope);
+    public static void write_buf(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(write_buf$LAYOUT, write_buf$OFFSET, fieldValue);
     }
+
     /**
-     * {@snippet :
- * int (*lock)(char*,struct fuse_file_info*,int,struct flock*);
+     * {@snippet lang=c :
+     * int (*read_buf)(const char *, struct fuse_bufvec **, size_t, off_t, struct fuse_file_info *)
      * }
      */
-    public interface lock {
+    public static class read_buf {
 
-        int apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1, int _x2, java.lang.foreign.MemorySegment _x3);
-        static MemorySegment allocate(lock fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$30.const$1, fi, constants$30.const$0, scope);
+        read_buf() {
+            // Should not be called directly
         }
-        static lock ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1, int __x2, java.lang.foreign.MemorySegment __x3) -> {
-                try {
-                    return (int)constants$30.const$2.invokeExact(symbol, __x0, __x1, __x2, __x3);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, MemorySegment _x1, long _x2, long _x3, MemorySegment _x4);
         }
-    }
 
-    public static VarHandle lock$VH() {
-        return constants$30.const$3;
-    }
-    /**
-     * Getter for field:
-     * {@snippet :
-     * int (*lock)(char*,struct fuse_file_info*,int,struct flock*);
-     * }
-     */
-    public static MemorySegment lock$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$30.const$3.get(seg);
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER,
+            fuse_h.C_LONG,
+            fuse_h.C_LONG,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(read_buf.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(read_buf.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1, long _x2, long _x3, MemorySegment _x4) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2, _x3, _x4);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
     }
+
+    private static final AddressLayout read_buf$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("read_buf"));
+
     /**
-     * Setter for field:
-     * {@snippet :
-     * int (*lock)(char*,struct fuse_file_info*,int,struct flock*);
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*read_buf)(const char *, struct fuse_bufvec **, size_t, off_t, struct fuse_file_info *)
      * }
      */
-    public static void lock$set(MemorySegment seg, MemorySegment x) {
-        constants$30.const$3.set(seg, x);
-    }
-    public static MemorySegment lock$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$30.const$3.get(seg.asSlice(index*sizeof()));
-    }
-    public static void lock$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$30.const$3.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static lock lock(MemorySegment segment, Arena scope) {
-        return lock.ofAddress(lock$get(segment), scope);
+    public static final AddressLayout read_buf$layout() {
+        return read_buf$LAYOUT;
     }
+
+    private static final long read_buf$OFFSET = 296;
+
     /**
-     * {@snippet :
- * int (*utimens)(char*,struct timespec*,struct fuse_file_info*);
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*read_buf)(const char *, struct fuse_bufvec **, size_t, off_t, struct fuse_file_info *)
      * }
      */
-    public interface utimens {
-
-        int apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1, java.lang.foreign.MemorySegment _x2);
-        static MemorySegment allocate(utimens fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$30.const$4, fi, constants$14.const$5, scope);
-        }
-        static utimens ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1, java.lang.foreign.MemorySegment __x2) -> {
-                try {
-                    return (int)constants$15.const$1.invokeExact(symbol, __x0, __x1, __x2);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
-        }
+    public static final long read_buf$offset() {
+        return read_buf$OFFSET;
     }
 
-    public static VarHandle utimens$VH() {
-        return constants$30.const$5;
-    }
     /**
      * Getter for field:
-     * {@snippet :
-     * int (*utimens)(char*,struct timespec*,struct fuse_file_info*);
+     * {@snippet lang=c :
+     * int (*read_buf)(const char *, struct fuse_bufvec **, size_t, off_t, struct fuse_file_info *)
      * }
      */
-    public static MemorySegment utimens$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$30.const$5.get(seg);
+    public static MemorySegment read_buf(MemorySegment struct) {
+        return struct.get(read_buf$LAYOUT, read_buf$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int (*utimens)(char*,struct timespec*,struct fuse_file_info*);
+     * {@snippet lang=c :
+     * int (*read_buf)(const char *, struct fuse_bufvec **, size_t, off_t, struct fuse_file_info *)
      * }
      */
-    public static void utimens$set(MemorySegment seg, MemorySegment x) {
-        constants$30.const$5.set(seg, x);
-    }
-    public static MemorySegment utimens$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$30.const$5.get(seg.asSlice(index*sizeof()));
-    }
-    public static void utimens$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$30.const$5.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static utimens utimens(MemorySegment segment, Arena scope) {
-        return utimens.ofAddress(utimens$get(segment), scope);
+    public static void read_buf(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(read_buf$LAYOUT, read_buf$OFFSET, fieldValue);
     }
+
     /**
-     * {@snippet :
- * int (*bmap)(char*,unsigned long,unsigned long*);
+     * {@snippet lang=c :
+     * int (*flock)(const char *, struct fuse_file_info *, int)
      * }
      */
-    public interface bmap {
+    public static class flock {
 
-        int apply(java.lang.foreign.MemorySegment _x0, long _x1, java.lang.foreign.MemorySegment _x2);
-        static MemorySegment allocate(bmap fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$31.const$0, fi, constants$21.const$3, scope);
+        flock() {
+            // Should not be called directly
         }
-        static bmap ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, long __x1, java.lang.foreign.MemorySegment __x2) -> {
-                try {
-                    return (int)constants$21.const$5.invokeExact(symbol, __x0, __x1, __x2);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, MemorySegment _x1, int _x2);
         }
-    }
 
-    public static VarHandle bmap$VH() {
-        return constants$31.const$1;
-    }
-    /**
-     * Getter for field:
-     * {@snippet :
-     * int (*bmap)(char*,unsigned long,unsigned long*);
-     * }
-     */
-    public static MemorySegment bmap$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$31.const$1.get(seg);
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER,
+            fuse_h.C_INT
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(flock.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(flock.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1, int _x2) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
     }
+
+    private static final AddressLayout flock$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("flock"));
+
     /**
-     * Setter for field:
-     * {@snippet :
-     * int (*bmap)(char*,unsigned long,unsigned long*);
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*flock)(const char *, struct fuse_file_info *, int)
      * }
      */
-    public static void bmap$set(MemorySegment seg, MemorySegment x) {
-        constants$31.const$1.set(seg, x);
-    }
-    public static MemorySegment bmap$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$31.const$1.get(seg.asSlice(index*sizeof()));
-    }
-    public static void bmap$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$31.const$1.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static bmap bmap(MemorySegment segment, Arena scope) {
-        return bmap.ofAddress(bmap$get(segment), scope);
+    public static final AddressLayout flock$layout() {
+        return flock$LAYOUT;
     }
+
+    private static final long flock$OFFSET = 304;
+
     /**
-     * {@snippet :
- * int (*ioctl)(char*,unsigned int,void*,struct fuse_file_info*,unsigned int,void*);
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*flock)(const char *, struct fuse_file_info *, int)
      * }
      */
-    public interface ioctl {
-
-        int apply(java.lang.foreign.MemorySegment _x0, int _x1, java.lang.foreign.MemorySegment _x2, java.lang.foreign.MemorySegment _x3, int _x4, java.lang.foreign.MemorySegment _x5);
-        static MemorySegment allocate(ioctl fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$31.const$3, fi, constants$31.const$2, scope);
-        }
-        static ioctl ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, int __x1, java.lang.foreign.MemorySegment __x2, java.lang.foreign.MemorySegment __x3, int __x4, java.lang.foreign.MemorySegment __x5) -> {
-                try {
-                    return (int)constants$31.const$4.invokeExact(symbol, __x0, __x1, __x2, __x3, __x4, __x5);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
-        }
+    public static final long flock$offset() {
+        return flock$OFFSET;
     }
 
-    public static VarHandle ioctl$VH() {
-        return constants$31.const$5;
-    }
     /**
      * Getter for field:
-     * {@snippet :
-     * int (*ioctl)(char*,unsigned int,void*,struct fuse_file_info*,unsigned int,void*);
+     * {@snippet lang=c :
+     * int (*flock)(const char *, struct fuse_file_info *, int)
      * }
      */
-    public static MemorySegment ioctl$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$31.const$5.get(seg);
+    public static MemorySegment flock(MemorySegment struct) {
+        return struct.get(flock$LAYOUT, flock$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int (*ioctl)(char*,unsigned int,void*,struct fuse_file_info*,unsigned int,void*);
+     * {@snippet lang=c :
+     * int (*flock)(const char *, struct fuse_file_info *, int)
      * }
      */
-    public static void ioctl$set(MemorySegment seg, MemorySegment x) {
-        constants$31.const$5.set(seg, x);
-    }
-    public static MemorySegment ioctl$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$31.const$5.get(seg.asSlice(index*sizeof()));
-    }
-    public static void ioctl$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$31.const$5.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static ioctl ioctl(MemorySegment segment, Arena scope) {
-        return ioctl.ofAddress(ioctl$get(segment), scope);
+    public static void flock(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(flock$LAYOUT, flock$OFFSET, fieldValue);
     }
+
     /**
-     * {@snippet :
- * int (*poll)(char*,struct fuse_file_info*,struct fuse_pollhandle*,unsigned int*);
+     * {@snippet lang=c :
+     * int (*fallocate)(const char *, int, off_t, off_t, struct fuse_file_info *)
      * }
      */
-    public interface poll {
+    public static class fallocate {
 
-        int apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1, java.lang.foreign.MemorySegment _x2, java.lang.foreign.MemorySegment _x3);
-        static MemorySegment allocate(poll fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$32.const$1, fi, constants$32.const$0, scope);
+        fallocate() {
+            // Should not be called directly
         }
-        static poll ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1, java.lang.foreign.MemorySegment __x2, java.lang.foreign.MemorySegment __x3) -> {
-                try {
-                    return (int)constants$32.const$2.invokeExact(symbol, __x0, __x1, __x2, __x3);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, int _x1, long _x2, long _x3, MemorySegment _x4);
         }
-    }
 
-    public static VarHandle poll$VH() {
-        return constants$32.const$3;
-    }
-    /**
-     * Getter for field:
-     * {@snippet :
-     * int (*poll)(char*,struct fuse_file_info*,struct fuse_pollhandle*,unsigned int*);
-     * }
-     */
-    public static MemorySegment poll$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$32.const$3.get(seg);
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_INT,
+            fuse_h.C_LONG,
+            fuse_h.C_LONG,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(fallocate.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(fallocate.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, int _x1, long _x2, long _x3, MemorySegment _x4) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2, _x3, _x4);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
     }
+
+    private static final AddressLayout fallocate$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("fallocate"));
+
     /**
-     * Setter for field:
-     * {@snippet :
-     * int (*poll)(char*,struct fuse_file_info*,struct fuse_pollhandle*,unsigned int*);
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*fallocate)(const char *, int, off_t, off_t, struct fuse_file_info *)
      * }
      */
-    public static void poll$set(MemorySegment seg, MemorySegment x) {
-        constants$32.const$3.set(seg, x);
-    }
-    public static MemorySegment poll$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$32.const$3.get(seg.asSlice(index*sizeof()));
-    }
-    public static void poll$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$32.const$3.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static poll poll(MemorySegment segment, Arena scope) {
-        return poll.ofAddress(poll$get(segment), scope);
+    public static final AddressLayout fallocate$layout() {
+        return fallocate$LAYOUT;
     }
+
+    private static final long fallocate$OFFSET = 312;
+
     /**
-     * {@snippet :
- * int (*write_buf)(char*,struct fuse_bufvec*,long,struct fuse_file_info*);
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*fallocate)(const char *, int, off_t, off_t, struct fuse_file_info *)
      * }
      */
-    public interface write_buf {
-
-        int apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1, long _x2, java.lang.foreign.MemorySegment _x3);
-        static MemorySegment allocate(write_buf fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$32.const$5, fi, constants$32.const$4, scope);
-        }
-        static write_buf ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1, long __x2, java.lang.foreign.MemorySegment __x3) -> {
-                try {
-                    return (int)constants$33.const$0.invokeExact(symbol, __x0, __x1, __x2, __x3);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
-        }
+    public static final long fallocate$offset() {
+        return fallocate$OFFSET;
     }
 
-    public static VarHandle write_buf$VH() {
-        return constants$33.const$1;
-    }
     /**
      * Getter for field:
-     * {@snippet :
-     * int (*write_buf)(char*,struct fuse_bufvec*,long,struct fuse_file_info*);
+     * {@snippet lang=c :
+     * int (*fallocate)(const char *, int, off_t, off_t, struct fuse_file_info *)
      * }
      */
-    public static MemorySegment write_buf$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$33.const$1.get(seg);
+    public static MemorySegment fallocate(MemorySegment struct) {
+        return struct.get(fallocate$LAYOUT, fallocate$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int (*write_buf)(char*,struct fuse_bufvec*,long,struct fuse_file_info*);
+     * {@snippet lang=c :
+     * int (*fallocate)(const char *, int, off_t, off_t, struct fuse_file_info *)
      * }
      */
-    public static void write_buf$set(MemorySegment seg, MemorySegment x) {
-        constants$33.const$1.set(seg, x);
-    }
-    public static MemorySegment write_buf$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$33.const$1.get(seg.asSlice(index*sizeof()));
-    }
-    public static void write_buf$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$33.const$1.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static write_buf write_buf(MemorySegment segment, Arena scope) {
-        return write_buf.ofAddress(write_buf$get(segment), scope);
+    public static void fallocate(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(fallocate$LAYOUT, fallocate$OFFSET, fieldValue);
     }
+
     /**
-     * {@snippet :
- * int (*read_buf)(char*,struct fuse_bufvec**,unsigned long,long,struct fuse_file_info*);
+     * {@snippet lang=c :
+     * ssize_t (*copy_file_range)(const char *, struct fuse_file_info *, off_t, const char *, struct fuse_file_info *, off_t, size_t, int)
      * }
      */
-    public interface read_buf {
+    public static class copy_file_range {
 
-        int apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1, long _x2, long _x3, java.lang.foreign.MemorySegment _x4);
-        static MemorySegment allocate(read_buf fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$33.const$2, fi, constants$22.const$3, scope);
+        copy_file_range() {
+            // Should not be called directly
         }
-        static read_buf ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1, long __x2, long __x3, java.lang.foreign.MemorySegment __x4) -> {
-                try {
-                    return (int)constants$22.const$5.invokeExact(symbol, __x0, __x1, __x2, __x3, __x4);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            long apply(MemorySegment _x0, MemorySegment _x1, long _x2, MemorySegment _x3, MemorySegment _x4, long _x5, long _x6, int _x7);
         }
-    }
 
-    public static VarHandle read_buf$VH() {
-        return constants$33.const$3;
-    }
-    /**
-     * Getter for field:
-     * {@snippet :
-     * int (*read_buf)(char*,struct fuse_bufvec**,unsigned long,long,struct fuse_file_info*);
-     * }
-     */
-    public static MemorySegment read_buf$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$33.const$3.get(seg);
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_LONG,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER,
+            fuse_h.C_LONG,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER,
+            fuse_h.C_LONG,
+            fuse_h.C_LONG,
+            fuse_h.C_INT
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(copy_file_range.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(copy_file_range.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static long invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1, long _x2, MemorySegment _x3, MemorySegment _x4, long _x5, long _x6, int _x7) {
+            try {
+                return (long) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2, _x3, _x4, _x5, _x6, _x7);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
     }
+
+    private static final AddressLayout copy_file_range$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("copy_file_range"));
+
     /**
-     * Setter for field:
-     * {@snippet :
-     * int (*read_buf)(char*,struct fuse_bufvec**,unsigned long,long,struct fuse_file_info*);
+     * Layout for field:
+     * {@snippet lang=c :
+     * ssize_t (*copy_file_range)(const char *, struct fuse_file_info *, off_t, const char *, struct fuse_file_info *, off_t, size_t, int)
      * }
      */
-    public static void read_buf$set(MemorySegment seg, MemorySegment x) {
-        constants$33.const$3.set(seg, x);
-    }
-    public static MemorySegment read_buf$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$33.const$3.get(seg.asSlice(index*sizeof()));
-    }
-    public static void read_buf$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$33.const$3.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static read_buf read_buf(MemorySegment segment, Arena scope) {
-        return read_buf.ofAddress(read_buf$get(segment), scope);
+    public static final AddressLayout copy_file_range$layout() {
+        return copy_file_range$LAYOUT;
     }
+
+    private static final long copy_file_range$OFFSET = 320;
+
     /**
-     * {@snippet :
- * int (*flock)(char*,struct fuse_file_info*,int);
+     * Offset for field:
+     * {@snippet lang=c :
+     * ssize_t (*copy_file_range)(const char *, struct fuse_file_info *, off_t, const char *, struct fuse_file_info *, off_t, size_t, int)
      * }
      */
-    public interface flock {
-
-        int apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1, int _x2);
-        static MemorySegment allocate(flock fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$33.const$4, fi, constants$19.const$1, scope);
-        }
-        static flock ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1, int __x2) -> {
-                try {
-                    return (int)constants$19.const$3.invokeExact(symbol, __x0, __x1, __x2);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
-        }
+    public static final long copy_file_range$offset() {
+        return copy_file_range$OFFSET;
     }
 
-    public static VarHandle flock$VH() {
-        return constants$33.const$5;
-    }
     /**
      * Getter for field:
-     * {@snippet :
-     * int (*flock)(char*,struct fuse_file_info*,int);
+     * {@snippet lang=c :
+     * ssize_t (*copy_file_range)(const char *, struct fuse_file_info *, off_t, const char *, struct fuse_file_info *, off_t, size_t, int)
      * }
      */
-    public static MemorySegment flock$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$33.const$5.get(seg);
+    public static MemorySegment copy_file_range(MemorySegment struct) {
+        return struct.get(copy_file_range$LAYOUT, copy_file_range$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int (*flock)(char*,struct fuse_file_info*,int);
+     * {@snippet lang=c :
+     * ssize_t (*copy_file_range)(const char *, struct fuse_file_info *, off_t, const char *, struct fuse_file_info *, off_t, size_t, int)
      * }
      */
-    public static void flock$set(MemorySegment seg, MemorySegment x) {
-        constants$33.const$5.set(seg, x);
-    }
-    public static MemorySegment flock$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$33.const$5.get(seg.asSlice(index*sizeof()));
-    }
-    public static void flock$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$33.const$5.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static flock flock(MemorySegment segment, Arena scope) {
-        return flock.ofAddress(flock$get(segment), scope);
+    public static void copy_file_range(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(copy_file_range$LAYOUT, copy_file_range$OFFSET, fieldValue);
     }
+
     /**
-     * {@snippet :
- * int (*fallocate)(char*,int,long,long,struct fuse_file_info*);
+     * {@snippet lang=c :
+     * off_t (*lseek)(const char *, off_t, int, struct fuse_file_info *)
      * }
      */
-    public interface fallocate {
+    public static class lseek {
 
-        int apply(java.lang.foreign.MemorySegment _x0, int _x1, long _x2, long _x3, java.lang.foreign.MemorySegment _x4);
-        static MemorySegment allocate(fallocate fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$34.const$1, fi, constants$34.const$0, scope);
+        lseek() {
+            // Should not be called directly
         }
-        static fallocate ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, int __x1, long __x2, long __x3, java.lang.foreign.MemorySegment __x4) -> {
-                try {
-                    return (int)constants$34.const$2.invokeExact(symbol, __x0, __x1, __x2, __x3, __x4);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            long apply(MemorySegment _x0, long _x1, int _x2, MemorySegment _x3);
         }
-    }
 
-    public static VarHandle fallocate$VH() {
-        return constants$34.const$3;
-    }
-    /**
-     * Getter for field:
-     * {@snippet :
-     * int (*fallocate)(char*,int,long,long,struct fuse_file_info*);
-     * }
-     */
-    public static MemorySegment fallocate$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$34.const$3.get(seg);
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_LONG,
+            fuse_h.C_POINTER,
+            fuse_h.C_LONG,
+            fuse_h.C_INT,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(lseek.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(lseek.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static long invoke(MemorySegment funcPtr,MemorySegment _x0, long _x1, int _x2, MemorySegment _x3) {
+            try {
+                return (long) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2, _x3);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
     }
+
+    private static final AddressLayout lseek$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("lseek"));
+
     /**
-     * Setter for field:
-     * {@snippet :
-     * int (*fallocate)(char*,int,long,long,struct fuse_file_info*);
+     * Layout for field:
+     * {@snippet lang=c :
+     * off_t (*lseek)(const char *, off_t, int, struct fuse_file_info *)
      * }
      */
-    public static void fallocate$set(MemorySegment seg, MemorySegment x) {
-        constants$34.const$3.set(seg, x);
-    }
-    public static MemorySegment fallocate$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$34.const$3.get(seg.asSlice(index*sizeof()));
-    }
-    public static void fallocate$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$34.const$3.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static fallocate fallocate(MemorySegment segment, Arena scope) {
-        return fallocate.ofAddress(fallocate$get(segment), scope);
+    public static final AddressLayout lseek$layout() {
+        return lseek$LAYOUT;
     }
+
+    private static final long lseek$OFFSET = 328;
+
     /**
-     * {@snippet :
- * long (*copy_file_range)(char*,struct fuse_file_info*,long,char*,struct fuse_file_info*,long,unsigned long,int);
+     * Offset for field:
+     * {@snippet lang=c :
+     * off_t (*lseek)(const char *, off_t, int, struct fuse_file_info *)
      * }
      */
-    public interface copy_file_range {
-
-        long apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1, long _x2, java.lang.foreign.MemorySegment _x3, java.lang.foreign.MemorySegment _x4, long _x5, long _x6, int _x7);
-        static MemorySegment allocate(copy_file_range fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$34.const$5, fi, constants$34.const$4, scope);
-        }
-        static copy_file_range ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1, long __x2, java.lang.foreign.MemorySegment __x3, java.lang.foreign.MemorySegment __x4, long __x5, long __x6, int __x7) -> {
-                try {
-                    return (long)constants$35.const$0.invokeExact(symbol, __x0, __x1, __x2, __x3, __x4, __x5, __x6, __x7);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
-        }
+    public static final long lseek$offset() {
+        return lseek$OFFSET;
     }
 
-    public static VarHandle copy_file_range$VH() {
-        return constants$35.const$1;
-    }
     /**
      * Getter for field:
-     * {@snippet :
-     * long (*copy_file_range)(char*,struct fuse_file_info*,long,char*,struct fuse_file_info*,long,unsigned long,int);
+     * {@snippet lang=c :
+     * off_t (*lseek)(const char *, off_t, int, struct fuse_file_info *)
      * }
      */
-    public static MemorySegment copy_file_range$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$35.const$1.get(seg);
+    public static MemorySegment lseek(MemorySegment struct) {
+        return struct.get(lseek$LAYOUT, lseek$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * long (*copy_file_range)(char*,struct fuse_file_info*,long,char*,struct fuse_file_info*,long,unsigned long,int);
+     * {@snippet lang=c :
+     * off_t (*lseek)(const char *, off_t, int, struct fuse_file_info *)
      * }
      */
-    public static void copy_file_range$set(MemorySegment seg, MemorySegment x) {
-        constants$35.const$1.set(seg, x);
+    public static void lseek(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(lseek$LAYOUT, lseek$OFFSET, fieldValue);
     }
-    public static MemorySegment copy_file_range$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$35.const$1.get(seg.asSlice(index*sizeof()));
-    }
-    public static void copy_file_range$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$35.const$1.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static copy_file_range copy_file_range(MemorySegment segment, Arena scope) {
-        return copy_file_range.ofAddress(copy_file_range$get(segment), scope);
+
+    /**
+     * Obtains a slice of {@code arrayParam} which selects the array element at {@code index}.
+     * The returned segment has address {@code arrayParam.address() + index * layout().byteSize()}
+     */
+    public static MemorySegment asSlice(MemorySegment array, long index) {
+        return array.asSlice(layout().byteSize() * index);
     }
+
     /**
-     * {@snippet :
- * long (*lseek)(char*,long,int,struct fuse_file_info*);
-     * }
+     * The size (in bytes) of this struct
      */
-    public interface lseek {
+    public static long sizeof() { return layout().byteSize(); }
 
-        long apply(java.lang.foreign.MemorySegment _x0, long _x1, int _x2, java.lang.foreign.MemorySegment _x3);
-        static MemorySegment allocate(lseek fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$35.const$3, fi, constants$35.const$2, scope);
-        }
-        static lseek ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, long __x1, int __x2, java.lang.foreign.MemorySegment __x3) -> {
-                try {
-                    return (long)constants$35.const$4.invokeExact(symbol, __x0, __x1, __x2, __x3);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
-        }
+    /**
+     * Allocate a segment of size {@code layout().byteSize()} using {@code allocator}
+     */
+    public static MemorySegment allocate(SegmentAllocator allocator) {
+        return allocator.allocate(layout());
     }
 
-    public static VarHandle lseek$VH() {
-        return constants$35.const$5;
-    }
     /**
-     * Getter for field:
-     * {@snippet :
-     * long (*lseek)(char*,long,int,struct fuse_file_info*);
-     * }
+     * Allocate an array of size {@code elementCount} using {@code allocator}.
+     * The returned segment has size {@code elementCount * layout().byteSize()}.
      */
-    public static MemorySegment lseek$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$35.const$5.get(seg);
+    public static MemorySegment allocateArray(long elementCount, SegmentAllocator allocator) {
+        return allocator.allocate(MemoryLayout.sequenceLayout(elementCount, layout()));
     }
+
     /**
-     * Setter for field:
-     * {@snippet :
-     * long (*lseek)(char*,long,int,struct fuse_file_info*);
-     * }
+     * Reinterprets {@code addr} using target {@code arena} and {@code cleanupAction) (if any).
+     * The returned segment has size {@code layout().byteSize()}
      */
-    public static void lseek$set(MemorySegment seg, MemorySegment x) {
-        constants$35.const$5.set(seg, x);
-    }
-    public static MemorySegment lseek$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$35.const$5.get(seg.asSlice(index*sizeof()));
-    }
-    public static void lseek$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$35.const$5.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static lseek lseek(MemorySegment segment, Arena scope) {
-        return lseek.ofAddress(lseek$get(segment), scope);
+    public static MemorySegment reinterpret(MemorySegment addr, Arena arena, Consumer<MemorySegment> cleanup) {
+        return reinterpret(addr, 1, arena, cleanup);
     }
-    public static long sizeof() { return $LAYOUT().byteSize(); }
-    public static MemorySegment allocate(SegmentAllocator allocator) { return allocator.allocate($LAYOUT()); }
-    public static MemorySegment allocateArray(long len, SegmentAllocator allocator) {
-        return allocator.allocate(MemoryLayout.sequenceLayout(len, $LAYOUT()));
+
+    /**
+     * Reinterprets {@code addr} using target {@code arena} and {@code cleanupAction) (if any).
+     * The returned segment has size {@code elementCount * layout().byteSize()}
+     */
+    public static MemorySegment reinterpret(MemorySegment addr, long elementCount, Arena arena, Consumer<MemorySegment> cleanup) {
+        return addr.reinterpret(layout().byteSize() * elementCount, arena, cleanup);
     }
-    public static MemorySegment ofAddress(MemorySegment addr, Arena scope) { return RuntimeHelper.asArray(addr, $LAYOUT(), 1, scope); }
 }
 
-
diff --git a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/stat.java b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/stat.java
index 28dc4ce4..f91045f5 100644
--- a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/stat.java
+++ b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/stat.java
@@ -2,352 +2,803 @@
 
 package org.cryptomator.jfuse.linux.amd64.extr.fuse3;
 
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
+import java.lang.invoke.*;
 import java.lang.foreign.*;
+import java.nio.ByteOrder;
+import java.util.*;
+import java.util.function.*;
+import java.util.stream.*;
+
 import static java.lang.foreign.ValueLayout.*;
+import static java.lang.foreign.MemoryLayout.PathElement.*;
+
 /**
- * {@snippet :
+ * {@snippet lang=c :
  * struct stat {
- *     unsigned long st_dev;
- *     unsigned long st_ino;
- *     unsigned long st_nlink;
- *     unsigned int st_mode;
- *     unsigned int st_uid;
- *     unsigned int st_gid;
+ *     __dev_t st_dev;
+ *     __ino_t st_ino;
+ *     __nlink_t st_nlink;
+ *     __mode_t st_mode;
+ *     __uid_t st_uid;
+ *     __gid_t st_gid;
  *     int __pad0;
- *     unsigned long st_rdev;
- *     long st_size;
- *     long st_blksize;
- *     long st_blocks;
+ *     __dev_t st_rdev;
+ *     __off_t st_size;
+ *     __blksize_t st_blksize;
+ *     __blkcnt_t st_blocks;
  *     struct timespec st_atim;
  *     struct timespec st_mtim;
  *     struct timespec st_ctim;
- *     long __glibc_reserved[3];
- * };
+ *     __syscall_slong_t __glibc_reserved[3];
+ * }
  * }
  */
 public class stat {
 
-    public static MemoryLayout $LAYOUT() {
-        return constants$5.const$5;
+    stat() {
+        // Should not be called directly
+    }
+
+    private static final GroupLayout $LAYOUT = MemoryLayout.structLayout(
+        fuse_h.C_LONG.withName("st_dev"),
+        fuse_h.C_LONG.withName("st_ino"),
+        fuse_h.C_LONG.withName("st_nlink"),
+        fuse_h.C_INT.withName("st_mode"),
+        fuse_h.C_INT.withName("st_uid"),
+        fuse_h.C_INT.withName("st_gid"),
+        fuse_h.C_INT.withName("__pad0"),
+        fuse_h.C_LONG.withName("st_rdev"),
+        fuse_h.C_LONG.withName("st_size"),
+        fuse_h.C_LONG.withName("st_blksize"),
+        fuse_h.C_LONG.withName("st_blocks"),
+        timespec.layout().withName("st_atim"),
+        timespec.layout().withName("st_mtim"),
+        timespec.layout().withName("st_ctim"),
+        MemoryLayout.sequenceLayout(3, fuse_h.C_LONG).withName("__glibc_reserved")
+    ).withName("stat");
+
+    /**
+     * The layout of this struct
+     */
+    public static final GroupLayout layout() {
+        return $LAYOUT;
     }
-    public static VarHandle st_dev$VH() {
-        return constants$6.const$0;
+
+    private static final OfLong st_dev$LAYOUT = (OfLong)$LAYOUT.select(groupElement("st_dev"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * __dev_t st_dev
+     * }
+     */
+    public static final OfLong st_dev$layout() {
+        return st_dev$LAYOUT;
     }
+
+    private static final long st_dev$OFFSET = 0;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * __dev_t st_dev
+     * }
+     */
+    public static final long st_dev$offset() {
+        return st_dev$OFFSET;
+    }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned long st_dev;
+     * {@snippet lang=c :
+     * __dev_t st_dev
      * }
      */
-    public static long st_dev$get(MemorySegment seg) {
-        return (long)constants$6.const$0.get(seg);
+    public static long st_dev(MemorySegment struct) {
+        return struct.get(st_dev$LAYOUT, st_dev$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned long st_dev;
+     * {@snippet lang=c :
+     * __dev_t st_dev
      * }
      */
-    public static void st_dev$set(MemorySegment seg, long x) {
-        constants$6.const$0.set(seg, x);
+    public static void st_dev(MemorySegment struct, long fieldValue) {
+        struct.set(st_dev$LAYOUT, st_dev$OFFSET, fieldValue);
     }
-    public static long st_dev$get(MemorySegment seg, long index) {
-        return (long)constants$6.const$0.get(seg.asSlice(index*sizeof()));
-    }
-    public static void st_dev$set(MemorySegment seg, long index, long x) {
-        constants$6.const$0.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfLong st_ino$LAYOUT = (OfLong)$LAYOUT.select(groupElement("st_ino"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * __ino_t st_ino
+     * }
+     */
+    public static final OfLong st_ino$layout() {
+        return st_ino$LAYOUT;
     }
-    public static VarHandle st_ino$VH() {
-        return constants$6.const$1;
+
+    private static final long st_ino$OFFSET = 8;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * __ino_t st_ino
+     * }
+     */
+    public static final long st_ino$offset() {
+        return st_ino$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned long st_ino;
+     * {@snippet lang=c :
+     * __ino_t st_ino
      * }
      */
-    public static long st_ino$get(MemorySegment seg) {
-        return (long)constants$6.const$1.get(seg);
+    public static long st_ino(MemorySegment struct) {
+        return struct.get(st_ino$LAYOUT, st_ino$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned long st_ino;
+     * {@snippet lang=c :
+     * __ino_t st_ino
      * }
      */
-    public static void st_ino$set(MemorySegment seg, long x) {
-        constants$6.const$1.set(seg, x);
-    }
-    public static long st_ino$get(MemorySegment seg, long index) {
-        return (long)constants$6.const$1.get(seg.asSlice(index*sizeof()));
+    public static void st_ino(MemorySegment struct, long fieldValue) {
+        struct.set(st_ino$LAYOUT, st_ino$OFFSET, fieldValue);
     }
-    public static void st_ino$set(MemorySegment seg, long index, long x) {
-        constants$6.const$1.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfLong st_nlink$LAYOUT = (OfLong)$LAYOUT.select(groupElement("st_nlink"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * __nlink_t st_nlink
+     * }
+     */
+    public static final OfLong st_nlink$layout() {
+        return st_nlink$LAYOUT;
     }
-    public static VarHandle st_nlink$VH() {
-        return constants$6.const$2;
+
+    private static final long st_nlink$OFFSET = 16;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * __nlink_t st_nlink
+     * }
+     */
+    public static final long st_nlink$offset() {
+        return st_nlink$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned long st_nlink;
+     * {@snippet lang=c :
+     * __nlink_t st_nlink
      * }
      */
-    public static long st_nlink$get(MemorySegment seg) {
-        return (long)constants$6.const$2.get(seg);
+    public static long st_nlink(MemorySegment struct) {
+        return struct.get(st_nlink$LAYOUT, st_nlink$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned long st_nlink;
+     * {@snippet lang=c :
+     * __nlink_t st_nlink
      * }
      */
-    public static void st_nlink$set(MemorySegment seg, long x) {
-        constants$6.const$2.set(seg, x);
-    }
-    public static long st_nlink$get(MemorySegment seg, long index) {
-        return (long)constants$6.const$2.get(seg.asSlice(index*sizeof()));
+    public static void st_nlink(MemorySegment struct, long fieldValue) {
+        struct.set(st_nlink$LAYOUT, st_nlink$OFFSET, fieldValue);
     }
-    public static void st_nlink$set(MemorySegment seg, long index, long x) {
-        constants$6.const$2.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt st_mode$LAYOUT = (OfInt)$LAYOUT.select(groupElement("st_mode"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * __mode_t st_mode
+     * }
+     */
+    public static final OfInt st_mode$layout() {
+        return st_mode$LAYOUT;
     }
-    public static VarHandle st_mode$VH() {
-        return constants$6.const$3;
+
+    private static final long st_mode$OFFSET = 24;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * __mode_t st_mode
+     * }
+     */
+    public static final long st_mode$offset() {
+        return st_mode$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned int st_mode;
+     * {@snippet lang=c :
+     * __mode_t st_mode
      * }
      */
-    public static int st_mode$get(MemorySegment seg) {
-        return (int)constants$6.const$3.get(seg);
+    public static int st_mode(MemorySegment struct) {
+        return struct.get(st_mode$LAYOUT, st_mode$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned int st_mode;
+     * {@snippet lang=c :
+     * __mode_t st_mode
      * }
      */
-    public static void st_mode$set(MemorySegment seg, int x) {
-        constants$6.const$3.set(seg, x);
-    }
-    public static int st_mode$get(MemorySegment seg, long index) {
-        return (int)constants$6.const$3.get(seg.asSlice(index*sizeof()));
+    public static void st_mode(MemorySegment struct, int fieldValue) {
+        struct.set(st_mode$LAYOUT, st_mode$OFFSET, fieldValue);
     }
-    public static void st_mode$set(MemorySegment seg, long index, int x) {
-        constants$6.const$3.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt st_uid$LAYOUT = (OfInt)$LAYOUT.select(groupElement("st_uid"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * __uid_t st_uid
+     * }
+     */
+    public static final OfInt st_uid$layout() {
+        return st_uid$LAYOUT;
     }
-    public static VarHandle st_uid$VH() {
-        return constants$6.const$4;
+
+    private static final long st_uid$OFFSET = 28;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * __uid_t st_uid
+     * }
+     */
+    public static final long st_uid$offset() {
+        return st_uid$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned int st_uid;
+     * {@snippet lang=c :
+     * __uid_t st_uid
      * }
      */
-    public static int st_uid$get(MemorySegment seg) {
-        return (int)constants$6.const$4.get(seg);
+    public static int st_uid(MemorySegment struct) {
+        return struct.get(st_uid$LAYOUT, st_uid$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned int st_uid;
+     * {@snippet lang=c :
+     * __uid_t st_uid
      * }
      */
-    public static void st_uid$set(MemorySegment seg, int x) {
-        constants$6.const$4.set(seg, x);
-    }
-    public static int st_uid$get(MemorySegment seg, long index) {
-        return (int)constants$6.const$4.get(seg.asSlice(index*sizeof()));
+    public static void st_uid(MemorySegment struct, int fieldValue) {
+        struct.set(st_uid$LAYOUT, st_uid$OFFSET, fieldValue);
     }
-    public static void st_uid$set(MemorySegment seg, long index, int x) {
-        constants$6.const$4.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt st_gid$LAYOUT = (OfInt)$LAYOUT.select(groupElement("st_gid"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * __gid_t st_gid
+     * }
+     */
+    public static final OfInt st_gid$layout() {
+        return st_gid$LAYOUT;
     }
-    public static VarHandle st_gid$VH() {
-        return constants$6.const$5;
+
+    private static final long st_gid$OFFSET = 32;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * __gid_t st_gid
+     * }
+     */
+    public static final long st_gid$offset() {
+        return st_gid$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned int st_gid;
+     * {@snippet lang=c :
+     * __gid_t st_gid
      * }
      */
-    public static int st_gid$get(MemorySegment seg) {
-        return (int)constants$6.const$5.get(seg);
+    public static int st_gid(MemorySegment struct) {
+        return struct.get(st_gid$LAYOUT, st_gid$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned int st_gid;
+     * {@snippet lang=c :
+     * __gid_t st_gid
      * }
      */
-    public static void st_gid$set(MemorySegment seg, int x) {
-        constants$6.const$5.set(seg, x);
-    }
-    public static int st_gid$get(MemorySegment seg, long index) {
-        return (int)constants$6.const$5.get(seg.asSlice(index*sizeof()));
+    public static void st_gid(MemorySegment struct, int fieldValue) {
+        struct.set(st_gid$LAYOUT, st_gid$OFFSET, fieldValue);
     }
-    public static void st_gid$set(MemorySegment seg, long index, int x) {
-        constants$6.const$5.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt __pad0$LAYOUT = (OfInt)$LAYOUT.select(groupElement("__pad0"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int __pad0
+     * }
+     */
+    public static final OfInt __pad0$layout() {
+        return __pad0$LAYOUT;
     }
-    public static VarHandle __pad0$VH() {
-        return constants$7.const$0;
+
+    private static final long __pad0$OFFSET = 36;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int __pad0
+     * }
+     */
+    public static final long __pad0$offset() {
+        return __pad0$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int __pad0;
+     * {@snippet lang=c :
+     * int __pad0
      * }
      */
-    public static int __pad0$get(MemorySegment seg) {
-        return (int)constants$7.const$0.get(seg);
+    public static int __pad0(MemorySegment struct) {
+        return struct.get(__pad0$LAYOUT, __pad0$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int __pad0;
+     * {@snippet lang=c :
+     * int __pad0
+     * }
+     */
+    public static void __pad0(MemorySegment struct, int fieldValue) {
+        struct.set(__pad0$LAYOUT, __pad0$OFFSET, fieldValue);
+    }
+
+    private static final OfLong st_rdev$LAYOUT = (OfLong)$LAYOUT.select(groupElement("st_rdev"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * __dev_t st_rdev
      * }
      */
-    public static void __pad0$set(MemorySegment seg, int x) {
-        constants$7.const$0.set(seg, x);
+    public static final OfLong st_rdev$layout() {
+        return st_rdev$LAYOUT;
     }
-    public static int __pad0$get(MemorySegment seg, long index) {
-        return (int)constants$7.const$0.get(seg.asSlice(index*sizeof()));
+
+    private static final long st_rdev$OFFSET = 40;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * __dev_t st_rdev
+     * }
+     */
+    public static final long st_rdev$offset() {
+        return st_rdev$OFFSET;
+    }
+
+    /**
+     * Getter for field:
+     * {@snippet lang=c :
+     * __dev_t st_rdev
+     * }
+     */
+    public static long st_rdev(MemorySegment struct) {
+        return struct.get(st_rdev$LAYOUT, st_rdev$OFFSET);
+    }
+
+    /**
+     * Setter for field:
+     * {@snippet lang=c :
+     * __dev_t st_rdev
+     * }
+     */
+    public static void st_rdev(MemorySegment struct, long fieldValue) {
+        struct.set(st_rdev$LAYOUT, st_rdev$OFFSET, fieldValue);
     }
-    public static void __pad0$set(MemorySegment seg, long index, int x) {
-        constants$7.const$0.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfLong st_size$LAYOUT = (OfLong)$LAYOUT.select(groupElement("st_size"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * __off_t st_size
+     * }
+     */
+    public static final OfLong st_size$layout() {
+        return st_size$LAYOUT;
     }
-    public static VarHandle st_rdev$VH() {
-        return constants$7.const$1;
+
+    private static final long st_size$OFFSET = 48;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * __off_t st_size
+     * }
+     */
+    public static final long st_size$offset() {
+        return st_size$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned long st_rdev;
+     * {@snippet lang=c :
+     * __off_t st_size
      * }
      */
-    public static long st_rdev$get(MemorySegment seg) {
-        return (long)constants$7.const$1.get(seg);
+    public static long st_size(MemorySegment struct) {
+        return struct.get(st_size$LAYOUT, st_size$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned long st_rdev;
+     * {@snippet lang=c :
+     * __off_t st_size
+     * }
+     */
+    public static void st_size(MemorySegment struct, long fieldValue) {
+        struct.set(st_size$LAYOUT, st_size$OFFSET, fieldValue);
+    }
+
+    private static final OfLong st_blksize$LAYOUT = (OfLong)$LAYOUT.select(groupElement("st_blksize"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * __blksize_t st_blksize
      * }
      */
-    public static void st_rdev$set(MemorySegment seg, long x) {
-        constants$7.const$1.set(seg, x);
+    public static final OfLong st_blksize$layout() {
+        return st_blksize$LAYOUT;
     }
-    public static long st_rdev$get(MemorySegment seg, long index) {
-        return (long)constants$7.const$1.get(seg.asSlice(index*sizeof()));
+
+    private static final long st_blksize$OFFSET = 56;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * __blksize_t st_blksize
+     * }
+     */
+    public static final long st_blksize$offset() {
+        return st_blksize$OFFSET;
     }
-    public static void st_rdev$set(MemorySegment seg, long index, long x) {
-        constants$7.const$1.set(seg.asSlice(index*sizeof()), x);
+
+    /**
+     * Getter for field:
+     * {@snippet lang=c :
+     * __blksize_t st_blksize
+     * }
+     */
+    public static long st_blksize(MemorySegment struct) {
+        return struct.get(st_blksize$LAYOUT, st_blksize$OFFSET);
     }
-    public static VarHandle st_size$VH() {
-        return constants$7.const$2;
+
+    /**
+     * Setter for field:
+     * {@snippet lang=c :
+     * __blksize_t st_blksize
+     * }
+     */
+    public static void st_blksize(MemorySegment struct, long fieldValue) {
+        struct.set(st_blksize$LAYOUT, st_blksize$OFFSET, fieldValue);
     }
+
+    private static final OfLong st_blocks$LAYOUT = (OfLong)$LAYOUT.select(groupElement("st_blocks"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * __blkcnt_t st_blocks
+     * }
+     */
+    public static final OfLong st_blocks$layout() {
+        return st_blocks$LAYOUT;
+    }
+
+    private static final long st_blocks$OFFSET = 64;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * __blkcnt_t st_blocks
+     * }
+     */
+    public static final long st_blocks$offset() {
+        return st_blocks$OFFSET;
+    }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * long st_size;
+     * {@snippet lang=c :
+     * __blkcnt_t st_blocks
      * }
      */
-    public static long st_size$get(MemorySegment seg) {
-        return (long)constants$7.const$2.get(seg);
+    public static long st_blocks(MemorySegment struct) {
+        return struct.get(st_blocks$LAYOUT, st_blocks$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * long st_size;
+     * {@snippet lang=c :
+     * __blkcnt_t st_blocks
      * }
      */
-    public static void st_size$set(MemorySegment seg, long x) {
-        constants$7.const$2.set(seg, x);
+    public static void st_blocks(MemorySegment struct, long fieldValue) {
+        struct.set(st_blocks$LAYOUT, st_blocks$OFFSET, fieldValue);
     }
-    public static long st_size$get(MemorySegment seg, long index) {
-        return (long)constants$7.const$2.get(seg.asSlice(index*sizeof()));
+
+    private static final GroupLayout st_atim$LAYOUT = (GroupLayout)$LAYOUT.select(groupElement("st_atim"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * struct timespec st_atim
+     * }
+     */
+    public static final GroupLayout st_atim$layout() {
+        return st_atim$LAYOUT;
+    }
+
+    private static final long st_atim$OFFSET = 72;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * struct timespec st_atim
+     * }
+     */
+    public static final long st_atim$offset() {
+        return st_atim$OFFSET;
+    }
+
+    /**
+     * Getter for field:
+     * {@snippet lang=c :
+     * struct timespec st_atim
+     * }
+     */
+    public static MemorySegment st_atim(MemorySegment struct) {
+        return struct.asSlice(st_atim$OFFSET, st_atim$LAYOUT.byteSize());
+    }
+
+    /**
+     * Setter for field:
+     * {@snippet lang=c :
+     * struct timespec st_atim
+     * }
+     */
+    public static void st_atim(MemorySegment struct, MemorySegment fieldValue) {
+        MemorySegment.copy(fieldValue, 0L, struct, st_atim$OFFSET, st_atim$LAYOUT.byteSize());
     }
-    public static void st_size$set(MemorySegment seg, long index, long x) {
-        constants$7.const$2.set(seg.asSlice(index*sizeof()), x);
+
+    private static final GroupLayout st_mtim$LAYOUT = (GroupLayout)$LAYOUT.select(groupElement("st_mtim"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * struct timespec st_mtim
+     * }
+     */
+    public static final GroupLayout st_mtim$layout() {
+        return st_mtim$LAYOUT;
     }
-    public static VarHandle st_blksize$VH() {
-        return constants$7.const$3;
+
+    private static final long st_mtim$OFFSET = 88;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * struct timespec st_mtim
+     * }
+     */
+    public static final long st_mtim$offset() {
+        return st_mtim$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * long st_blksize;
+     * {@snippet lang=c :
+     * struct timespec st_mtim
      * }
      */
-    public static long st_blksize$get(MemorySegment seg) {
-        return (long)constants$7.const$3.get(seg);
+    public static MemorySegment st_mtim(MemorySegment struct) {
+        return struct.asSlice(st_mtim$OFFSET, st_mtim$LAYOUT.byteSize());
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * long st_blksize;
+     * {@snippet lang=c :
+     * struct timespec st_mtim
      * }
      */
-    public static void st_blksize$set(MemorySegment seg, long x) {
-        constants$7.const$3.set(seg, x);
+    public static void st_mtim(MemorySegment struct, MemorySegment fieldValue) {
+        MemorySegment.copy(fieldValue, 0L, struct, st_mtim$OFFSET, st_mtim$LAYOUT.byteSize());
     }
-    public static long st_blksize$get(MemorySegment seg, long index) {
-        return (long)constants$7.const$3.get(seg.asSlice(index*sizeof()));
+
+    private static final GroupLayout st_ctim$LAYOUT = (GroupLayout)$LAYOUT.select(groupElement("st_ctim"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * struct timespec st_ctim
+     * }
+     */
+    public static final GroupLayout st_ctim$layout() {
+        return st_ctim$LAYOUT;
+    }
+
+    private static final long st_ctim$OFFSET = 104;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * struct timespec st_ctim
+     * }
+     */
+    public static final long st_ctim$offset() {
+        return st_ctim$OFFSET;
+    }
+
+    /**
+     * Getter for field:
+     * {@snippet lang=c :
+     * struct timespec st_ctim
+     * }
+     */
+    public static MemorySegment st_ctim(MemorySegment struct) {
+        return struct.asSlice(st_ctim$OFFSET, st_ctim$LAYOUT.byteSize());
     }
-    public static void st_blksize$set(MemorySegment seg, long index, long x) {
-        constants$7.const$3.set(seg.asSlice(index*sizeof()), x);
+
+    /**
+     * Setter for field:
+     * {@snippet lang=c :
+     * struct timespec st_ctim
+     * }
+     */
+    public static void st_ctim(MemorySegment struct, MemorySegment fieldValue) {
+        MemorySegment.copy(fieldValue, 0L, struct, st_ctim$OFFSET, st_ctim$LAYOUT.byteSize());
     }
-    public static VarHandle st_blocks$VH() {
-        return constants$7.const$4;
+
+    private static final SequenceLayout __glibc_reserved$LAYOUT = (SequenceLayout)$LAYOUT.select(groupElement("__glibc_reserved"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * __syscall_slong_t __glibc_reserved[3]
+     * }
+     */
+    public static final SequenceLayout __glibc_reserved$layout() {
+        return __glibc_reserved$LAYOUT;
+    }
+
+    private static final long __glibc_reserved$OFFSET = 120;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * __syscall_slong_t __glibc_reserved[3]
+     * }
+     */
+    public static final long __glibc_reserved$offset() {
+        return __glibc_reserved$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * long st_blocks;
+     * {@snippet lang=c :
+     * __syscall_slong_t __glibc_reserved[3]
      * }
      */
-    public static long st_blocks$get(MemorySegment seg) {
-        return (long)constants$7.const$4.get(seg);
+    public static MemorySegment __glibc_reserved(MemorySegment struct) {
+        return struct.asSlice(__glibc_reserved$OFFSET, __glibc_reserved$LAYOUT.byteSize());
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * long st_blocks;
+     * {@snippet lang=c :
+     * __syscall_slong_t __glibc_reserved[3]
      * }
      */
-    public static void st_blocks$set(MemorySegment seg, long x) {
-        constants$7.const$4.set(seg, x);
+    public static void __glibc_reserved(MemorySegment struct, MemorySegment fieldValue) {
+        MemorySegment.copy(fieldValue, 0L, struct, __glibc_reserved$OFFSET, __glibc_reserved$LAYOUT.byteSize());
     }
-    public static long st_blocks$get(MemorySegment seg, long index) {
-        return (long)constants$7.const$4.get(seg.asSlice(index*sizeof()));
+
+    private static long[] __glibc_reserved$DIMS = { 3 };
+
+    /**
+     * Dimensions for array field:
+     * {@snippet lang=c :
+     * __syscall_slong_t __glibc_reserved[3]
+     * }
+     */
+    public static long[] __glibc_reserved$dimensions() {
+        return __glibc_reserved$DIMS;
     }
-    public static void st_blocks$set(MemorySegment seg, long index, long x) {
-        constants$7.const$4.set(seg.asSlice(index*sizeof()), x);
+    private static final VarHandle __glibc_reserved$ELEM_HANDLE = __glibc_reserved$LAYOUT.varHandle(sequenceElement());
+
+    /**
+     * Indexed getter for field:
+     * {@snippet lang=c :
+     * __syscall_slong_t __glibc_reserved[3]
+     * }
+     */
+    public static long __glibc_reserved(MemorySegment struct, long index0) {
+        return (long)__glibc_reserved$ELEM_HANDLE.get(struct, 0L, index0);
+    }
+
+    /**
+     * Indexed setter for field:
+     * {@snippet lang=c :
+     * __syscall_slong_t __glibc_reserved[3]
+     * }
+     */
+    public static void __glibc_reserved(MemorySegment struct, long index0, long fieldValue) {
+        __glibc_reserved$ELEM_HANDLE.set(struct, 0L, index0, fieldValue);
     }
-    public static MemorySegment st_atim$slice(MemorySegment seg) {
-        return seg.asSlice(72, 16);
+
+    /**
+     * Obtains a slice of {@code arrayParam} which selects the array element at {@code index}.
+     * The returned segment has address {@code arrayParam.address() + index * layout().byteSize()}
+     */
+    public static MemorySegment asSlice(MemorySegment array, long index) {
+        return array.asSlice(layout().byteSize() * index);
     }
-    public static MemorySegment st_mtim$slice(MemorySegment seg) {
-        return seg.asSlice(88, 16);
+
+    /**
+     * The size (in bytes) of this struct
+     */
+    public static long sizeof() { return layout().byteSize(); }
+
+    /**
+     * Allocate a segment of size {@code layout().byteSize()} using {@code allocator}
+     */
+    public static MemorySegment allocate(SegmentAllocator allocator) {
+        return allocator.allocate(layout());
     }
-    public static MemorySegment st_ctim$slice(MemorySegment seg) {
-        return seg.asSlice(104, 16);
+
+    /**
+     * Allocate an array of size {@code elementCount} using {@code allocator}.
+     * The returned segment has size {@code elementCount * layout().byteSize()}.
+     */
+    public static MemorySegment allocateArray(long elementCount, SegmentAllocator allocator) {
+        return allocator.allocate(MemoryLayout.sequenceLayout(elementCount, layout()));
     }
-    public static MemorySegment __glibc_reserved$slice(MemorySegment seg) {
-        return seg.asSlice(120, 24);
+
+    /**
+     * Reinterprets {@code addr} using target {@code arena} and {@code cleanupAction) (if any).
+     * The returned segment has size {@code layout().byteSize()}
+     */
+    public static MemorySegment reinterpret(MemorySegment addr, Arena arena, Consumer<MemorySegment> cleanup) {
+        return reinterpret(addr, 1, arena, cleanup);
     }
-    public static long sizeof() { return $LAYOUT().byteSize(); }
-    public static MemorySegment allocate(SegmentAllocator allocator) { return allocator.allocate($LAYOUT()); }
-    public static MemorySegment allocateArray(long len, SegmentAllocator allocator) {
-        return allocator.allocate(MemoryLayout.sequenceLayout(len, $LAYOUT()));
+
+    /**
+     * Reinterprets {@code addr} using target {@code arena} and {@code cleanupAction) (if any).
+     * The returned segment has size {@code elementCount * layout().byteSize()}
+     */
+    public static MemorySegment reinterpret(MemorySegment addr, long elementCount, Arena arena, Consumer<MemorySegment> cleanup) {
+        return addr.reinterpret(layout().byteSize() * elementCount, arena, cleanup);
     }
-    public static MemorySegment ofAddress(MemorySegment addr, Arena scope) { return RuntimeHelper.asArray(addr, $LAYOUT(), 1, scope); }
 }
 
-
diff --git a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/statvfs.java b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/statvfs.java
index 9ba19be0..dc9b12b8 100644
--- a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/statvfs.java
+++ b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/statvfs.java
@@ -2,340 +2,665 @@
 
 package org.cryptomator.jfuse.linux.amd64.extr.fuse3;
 
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
+import java.lang.invoke.*;
 import java.lang.foreign.*;
+import java.nio.ByteOrder;
+import java.util.*;
+import java.util.function.*;
+import java.util.stream.*;
+
 import static java.lang.foreign.ValueLayout.*;
+import static java.lang.foreign.MemoryLayout.PathElement.*;
+
 /**
- * {@snippet :
+ * {@snippet lang=c :
  * struct statvfs {
  *     unsigned long f_bsize;
  *     unsigned long f_frsize;
- *     unsigned long f_blocks;
- *     unsigned long f_bfree;
- *     unsigned long f_bavail;
- *     unsigned long f_files;
- *     unsigned long f_ffree;
- *     unsigned long f_favail;
+ *     __fsblkcnt64_t f_blocks;
+ *     __fsblkcnt64_t f_bfree;
+ *     __fsblkcnt64_t f_bavail;
+ *     __fsfilcnt64_t f_files;
+ *     __fsfilcnt64_t f_ffree;
+ *     __fsfilcnt64_t f_favail;
  *     unsigned long f_fsid;
  *     unsigned long f_flag;
  *     unsigned long f_namemax;
  *     int __f_spare[6];
- * };
+ * }
  * }
  */
 public class statvfs {
 
-    public static MemoryLayout $LAYOUT() {
-        return constants$7.const$5;
+    statvfs() {
+        // Should not be called directly
     }
-    public static VarHandle f_bsize$VH() {
-        return constants$8.const$0;
+
+    private static final GroupLayout $LAYOUT = MemoryLayout.structLayout(
+        fuse_h.C_LONG.withName("f_bsize"),
+        fuse_h.C_LONG.withName("f_frsize"),
+        fuse_h.C_LONG.withName("f_blocks"),
+        fuse_h.C_LONG.withName("f_bfree"),
+        fuse_h.C_LONG.withName("f_bavail"),
+        fuse_h.C_LONG.withName("f_files"),
+        fuse_h.C_LONG.withName("f_ffree"),
+        fuse_h.C_LONG.withName("f_favail"),
+        fuse_h.C_LONG.withName("f_fsid"),
+        fuse_h.C_LONG.withName("f_flag"),
+        fuse_h.C_LONG.withName("f_namemax"),
+        MemoryLayout.sequenceLayout(6, fuse_h.C_INT).withName("__f_spare")
+    ).withName("statvfs");
+
+    /**
+     * The layout of this struct
+     */
+    public static final GroupLayout layout() {
+        return $LAYOUT;
     }
+
+    private static final OfLong f_bsize$LAYOUT = (OfLong)$LAYOUT.select(groupElement("f_bsize"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * unsigned long f_bsize
+     * }
+     */
+    public static final OfLong f_bsize$layout() {
+        return f_bsize$LAYOUT;
+    }
+
+    private static final long f_bsize$OFFSET = 0;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * unsigned long f_bsize
+     * }
+     */
+    public static final long f_bsize$offset() {
+        return f_bsize$OFFSET;
+    }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned long f_bsize;
+     * {@snippet lang=c :
+     * unsigned long f_bsize
      * }
      */
-    public static long f_bsize$get(MemorySegment seg) {
-        return (long)constants$8.const$0.get(seg);
+    public static long f_bsize(MemorySegment struct) {
+        return struct.get(f_bsize$LAYOUT, f_bsize$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned long f_bsize;
+     * {@snippet lang=c :
+     * unsigned long f_bsize
      * }
      */
-    public static void f_bsize$set(MemorySegment seg, long x) {
-        constants$8.const$0.set(seg, x);
-    }
-    public static long f_bsize$get(MemorySegment seg, long index) {
-        return (long)constants$8.const$0.get(seg.asSlice(index*sizeof()));
+    public static void f_bsize(MemorySegment struct, long fieldValue) {
+        struct.set(f_bsize$LAYOUT, f_bsize$OFFSET, fieldValue);
     }
-    public static void f_bsize$set(MemorySegment seg, long index, long x) {
-        constants$8.const$0.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfLong f_frsize$LAYOUT = (OfLong)$LAYOUT.select(groupElement("f_frsize"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * unsigned long f_frsize
+     * }
+     */
+    public static final OfLong f_frsize$layout() {
+        return f_frsize$LAYOUT;
     }
-    public static VarHandle f_frsize$VH() {
-        return constants$8.const$1;
+
+    private static final long f_frsize$OFFSET = 8;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * unsigned long f_frsize
+     * }
+     */
+    public static final long f_frsize$offset() {
+        return f_frsize$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned long f_frsize;
+     * {@snippet lang=c :
+     * unsigned long f_frsize
      * }
      */
-    public static long f_frsize$get(MemorySegment seg) {
-        return (long)constants$8.const$1.get(seg);
+    public static long f_frsize(MemorySegment struct) {
+        return struct.get(f_frsize$LAYOUT, f_frsize$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned long f_frsize;
+     * {@snippet lang=c :
+     * unsigned long f_frsize
      * }
      */
-    public static void f_frsize$set(MemorySegment seg, long x) {
-        constants$8.const$1.set(seg, x);
-    }
-    public static long f_frsize$get(MemorySegment seg, long index) {
-        return (long)constants$8.const$1.get(seg.asSlice(index*sizeof()));
+    public static void f_frsize(MemorySegment struct, long fieldValue) {
+        struct.set(f_frsize$LAYOUT, f_frsize$OFFSET, fieldValue);
     }
-    public static void f_frsize$set(MemorySegment seg, long index, long x) {
-        constants$8.const$1.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfLong f_blocks$LAYOUT = (OfLong)$LAYOUT.select(groupElement("f_blocks"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * __fsblkcnt64_t f_blocks
+     * }
+     */
+    public static final OfLong f_blocks$layout() {
+        return f_blocks$LAYOUT;
     }
-    public static VarHandle f_blocks$VH() {
-        return constants$8.const$2;
+
+    private static final long f_blocks$OFFSET = 16;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * __fsblkcnt64_t f_blocks
+     * }
+     */
+    public static final long f_blocks$offset() {
+        return f_blocks$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned long f_blocks;
+     * {@snippet lang=c :
+     * __fsblkcnt64_t f_blocks
      * }
      */
-    public static long f_blocks$get(MemorySegment seg) {
-        return (long)constants$8.const$2.get(seg);
+    public static long f_blocks(MemorySegment struct) {
+        return struct.get(f_blocks$LAYOUT, f_blocks$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned long f_blocks;
+     * {@snippet lang=c :
+     * __fsblkcnt64_t f_blocks
      * }
      */
-    public static void f_blocks$set(MemorySegment seg, long x) {
-        constants$8.const$2.set(seg, x);
-    }
-    public static long f_blocks$get(MemorySegment seg, long index) {
-        return (long)constants$8.const$2.get(seg.asSlice(index*sizeof()));
+    public static void f_blocks(MemorySegment struct, long fieldValue) {
+        struct.set(f_blocks$LAYOUT, f_blocks$OFFSET, fieldValue);
     }
-    public static void f_blocks$set(MemorySegment seg, long index, long x) {
-        constants$8.const$2.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfLong f_bfree$LAYOUT = (OfLong)$LAYOUT.select(groupElement("f_bfree"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * __fsblkcnt64_t f_bfree
+     * }
+     */
+    public static final OfLong f_bfree$layout() {
+        return f_bfree$LAYOUT;
     }
-    public static VarHandle f_bfree$VH() {
-        return constants$8.const$3;
+
+    private static final long f_bfree$OFFSET = 24;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * __fsblkcnt64_t f_bfree
+     * }
+     */
+    public static final long f_bfree$offset() {
+        return f_bfree$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned long f_bfree;
+     * {@snippet lang=c :
+     * __fsblkcnt64_t f_bfree
      * }
      */
-    public static long f_bfree$get(MemorySegment seg) {
-        return (long)constants$8.const$3.get(seg);
+    public static long f_bfree(MemorySegment struct) {
+        return struct.get(f_bfree$LAYOUT, f_bfree$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned long f_bfree;
+     * {@snippet lang=c :
+     * __fsblkcnt64_t f_bfree
      * }
      */
-    public static void f_bfree$set(MemorySegment seg, long x) {
-        constants$8.const$3.set(seg, x);
+    public static void f_bfree(MemorySegment struct, long fieldValue) {
+        struct.set(f_bfree$LAYOUT, f_bfree$OFFSET, fieldValue);
     }
-    public static long f_bfree$get(MemorySegment seg, long index) {
-        return (long)constants$8.const$3.get(seg.asSlice(index*sizeof()));
-    }
-    public static void f_bfree$set(MemorySegment seg, long index, long x) {
-        constants$8.const$3.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfLong f_bavail$LAYOUT = (OfLong)$LAYOUT.select(groupElement("f_bavail"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * __fsblkcnt64_t f_bavail
+     * }
+     */
+    public static final OfLong f_bavail$layout() {
+        return f_bavail$LAYOUT;
     }
-    public static VarHandle f_bavail$VH() {
-        return constants$8.const$4;
+
+    private static final long f_bavail$OFFSET = 32;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * __fsblkcnt64_t f_bavail
+     * }
+     */
+    public static final long f_bavail$offset() {
+        return f_bavail$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned long f_bavail;
+     * {@snippet lang=c :
+     * __fsblkcnt64_t f_bavail
      * }
      */
-    public static long f_bavail$get(MemorySegment seg) {
-        return (long)constants$8.const$4.get(seg);
+    public static long f_bavail(MemorySegment struct) {
+        return struct.get(f_bavail$LAYOUT, f_bavail$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned long f_bavail;
+     * {@snippet lang=c :
+     * __fsblkcnt64_t f_bavail
      * }
      */
-    public static void f_bavail$set(MemorySegment seg, long x) {
-        constants$8.const$4.set(seg, x);
-    }
-    public static long f_bavail$get(MemorySegment seg, long index) {
-        return (long)constants$8.const$4.get(seg.asSlice(index*sizeof()));
+    public static void f_bavail(MemorySegment struct, long fieldValue) {
+        struct.set(f_bavail$LAYOUT, f_bavail$OFFSET, fieldValue);
     }
-    public static void f_bavail$set(MemorySegment seg, long index, long x) {
-        constants$8.const$4.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfLong f_files$LAYOUT = (OfLong)$LAYOUT.select(groupElement("f_files"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * __fsfilcnt64_t f_files
+     * }
+     */
+    public static final OfLong f_files$layout() {
+        return f_files$LAYOUT;
     }
-    public static VarHandle f_files$VH() {
-        return constants$8.const$5;
+
+    private static final long f_files$OFFSET = 40;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * __fsfilcnt64_t f_files
+     * }
+     */
+    public static final long f_files$offset() {
+        return f_files$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned long f_files;
+     * {@snippet lang=c :
+     * __fsfilcnt64_t f_files
      * }
      */
-    public static long f_files$get(MemorySegment seg) {
-        return (long)constants$8.const$5.get(seg);
+    public static long f_files(MemorySegment struct) {
+        return struct.get(f_files$LAYOUT, f_files$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned long f_files;
+     * {@snippet lang=c :
+     * __fsfilcnt64_t f_files
      * }
      */
-    public static void f_files$set(MemorySegment seg, long x) {
-        constants$8.const$5.set(seg, x);
-    }
-    public static long f_files$get(MemorySegment seg, long index) {
-        return (long)constants$8.const$5.get(seg.asSlice(index*sizeof()));
+    public static void f_files(MemorySegment struct, long fieldValue) {
+        struct.set(f_files$LAYOUT, f_files$OFFSET, fieldValue);
     }
-    public static void f_files$set(MemorySegment seg, long index, long x) {
-        constants$8.const$5.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfLong f_ffree$LAYOUT = (OfLong)$LAYOUT.select(groupElement("f_ffree"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * __fsfilcnt64_t f_ffree
+     * }
+     */
+    public static final OfLong f_ffree$layout() {
+        return f_ffree$LAYOUT;
     }
-    public static VarHandle f_ffree$VH() {
-        return constants$9.const$0;
+
+    private static final long f_ffree$OFFSET = 48;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * __fsfilcnt64_t f_ffree
+     * }
+     */
+    public static final long f_ffree$offset() {
+        return f_ffree$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned long f_ffree;
+     * {@snippet lang=c :
+     * __fsfilcnt64_t f_ffree
      * }
      */
-    public static long f_ffree$get(MemorySegment seg) {
-        return (long)constants$9.const$0.get(seg);
+    public static long f_ffree(MemorySegment struct) {
+        return struct.get(f_ffree$LAYOUT, f_ffree$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned long f_ffree;
+     * {@snippet lang=c :
+     * __fsfilcnt64_t f_ffree
      * }
      */
-    public static void f_ffree$set(MemorySegment seg, long x) {
-        constants$9.const$0.set(seg, x);
-    }
-    public static long f_ffree$get(MemorySegment seg, long index) {
-        return (long)constants$9.const$0.get(seg.asSlice(index*sizeof()));
+    public static void f_ffree(MemorySegment struct, long fieldValue) {
+        struct.set(f_ffree$LAYOUT, f_ffree$OFFSET, fieldValue);
     }
-    public static void f_ffree$set(MemorySegment seg, long index, long x) {
-        constants$9.const$0.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfLong f_favail$LAYOUT = (OfLong)$LAYOUT.select(groupElement("f_favail"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * __fsfilcnt64_t f_favail
+     * }
+     */
+    public static final OfLong f_favail$layout() {
+        return f_favail$LAYOUT;
     }
-    public static VarHandle f_favail$VH() {
-        return constants$9.const$1;
+
+    private static final long f_favail$OFFSET = 56;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * __fsfilcnt64_t f_favail
+     * }
+     */
+    public static final long f_favail$offset() {
+        return f_favail$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned long f_favail;
+     * {@snippet lang=c :
+     * __fsfilcnt64_t f_favail
      * }
      */
-    public static long f_favail$get(MemorySegment seg) {
-        return (long)constants$9.const$1.get(seg);
+    public static long f_favail(MemorySegment struct) {
+        return struct.get(f_favail$LAYOUT, f_favail$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned long f_favail;
+     * {@snippet lang=c :
+     * __fsfilcnt64_t f_favail
      * }
      */
-    public static void f_favail$set(MemorySegment seg, long x) {
-        constants$9.const$1.set(seg, x);
-    }
-    public static long f_favail$get(MemorySegment seg, long index) {
-        return (long)constants$9.const$1.get(seg.asSlice(index*sizeof()));
+    public static void f_favail(MemorySegment struct, long fieldValue) {
+        struct.set(f_favail$LAYOUT, f_favail$OFFSET, fieldValue);
     }
-    public static void f_favail$set(MemorySegment seg, long index, long x) {
-        constants$9.const$1.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfLong f_fsid$LAYOUT = (OfLong)$LAYOUT.select(groupElement("f_fsid"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * unsigned long f_fsid
+     * }
+     */
+    public static final OfLong f_fsid$layout() {
+        return f_fsid$LAYOUT;
     }
-    public static VarHandle f_fsid$VH() {
-        return constants$9.const$2;
+
+    private static final long f_fsid$OFFSET = 64;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * unsigned long f_fsid
+     * }
+     */
+    public static final long f_fsid$offset() {
+        return f_fsid$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned long f_fsid;
+     * {@snippet lang=c :
+     * unsigned long f_fsid
      * }
      */
-    public static long f_fsid$get(MemorySegment seg) {
-        return (long)constants$9.const$2.get(seg);
+    public static long f_fsid(MemorySegment struct) {
+        return struct.get(f_fsid$LAYOUT, f_fsid$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned long f_fsid;
+     * {@snippet lang=c :
+     * unsigned long f_fsid
      * }
      */
-    public static void f_fsid$set(MemorySegment seg, long x) {
-        constants$9.const$2.set(seg, x);
+    public static void f_fsid(MemorySegment struct, long fieldValue) {
+        struct.set(f_fsid$LAYOUT, f_fsid$OFFSET, fieldValue);
     }
-    public static long f_fsid$get(MemorySegment seg, long index) {
-        return (long)constants$9.const$2.get(seg.asSlice(index*sizeof()));
-    }
-    public static void f_fsid$set(MemorySegment seg, long index, long x) {
-        constants$9.const$2.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfLong f_flag$LAYOUT = (OfLong)$LAYOUT.select(groupElement("f_flag"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * unsigned long f_flag
+     * }
+     */
+    public static final OfLong f_flag$layout() {
+        return f_flag$LAYOUT;
     }
-    public static VarHandle f_flag$VH() {
-        return constants$9.const$3;
+
+    private static final long f_flag$OFFSET = 72;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * unsigned long f_flag
+     * }
+     */
+    public static final long f_flag$offset() {
+        return f_flag$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned long f_flag;
+     * {@snippet lang=c :
+     * unsigned long f_flag
      * }
      */
-    public static long f_flag$get(MemorySegment seg) {
-        return (long)constants$9.const$3.get(seg);
+    public static long f_flag(MemorySegment struct) {
+        return struct.get(f_flag$LAYOUT, f_flag$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned long f_flag;
+     * {@snippet lang=c :
+     * unsigned long f_flag
      * }
      */
-    public static void f_flag$set(MemorySegment seg, long x) {
-        constants$9.const$3.set(seg, x);
+    public static void f_flag(MemorySegment struct, long fieldValue) {
+        struct.set(f_flag$LAYOUT, f_flag$OFFSET, fieldValue);
     }
-    public static long f_flag$get(MemorySegment seg, long index) {
-        return (long)constants$9.const$3.get(seg.asSlice(index*sizeof()));
+
+    private static final OfLong f_namemax$LAYOUT = (OfLong)$LAYOUT.select(groupElement("f_namemax"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * unsigned long f_namemax
+     * }
+     */
+    public static final OfLong f_namemax$layout() {
+        return f_namemax$LAYOUT;
     }
-    public static void f_flag$set(MemorySegment seg, long index, long x) {
-        constants$9.const$3.set(seg.asSlice(index*sizeof()), x);
+
+    private static final long f_namemax$OFFSET = 80;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * unsigned long f_namemax
+     * }
+     */
+    public static final long f_namemax$offset() {
+        return f_namemax$OFFSET;
     }
-    public static VarHandle f_namemax$VH() {
-        return constants$9.const$4;
+
+    /**
+     * Getter for field:
+     * {@snippet lang=c :
+     * unsigned long f_namemax
+     * }
+     */
+    public static long f_namemax(MemorySegment struct) {
+        return struct.get(f_namemax$LAYOUT, f_namemax$OFFSET);
     }
+
+    /**
+     * Setter for field:
+     * {@snippet lang=c :
+     * unsigned long f_namemax
+     * }
+     */
+    public static void f_namemax(MemorySegment struct, long fieldValue) {
+        struct.set(f_namemax$LAYOUT, f_namemax$OFFSET, fieldValue);
+    }
+
+    private static final SequenceLayout __f_spare$LAYOUT = (SequenceLayout)$LAYOUT.select(groupElement("__f_spare"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int __f_spare[6]
+     * }
+     */
+    public static final SequenceLayout __f_spare$layout() {
+        return __f_spare$LAYOUT;
+    }
+
+    private static final long __f_spare$OFFSET = 88;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int __f_spare[6]
+     * }
+     */
+    public static final long __f_spare$offset() {
+        return __f_spare$OFFSET;
+    }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned long f_namemax;
+     * {@snippet lang=c :
+     * int __f_spare[6]
      * }
      */
-    public static long f_namemax$get(MemorySegment seg) {
-        return (long)constants$9.const$4.get(seg);
+    public static MemorySegment __f_spare(MemorySegment struct) {
+        return struct.asSlice(__f_spare$OFFSET, __f_spare$LAYOUT.byteSize());
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned long f_namemax;
+     * {@snippet lang=c :
+     * int __f_spare[6]
+     * }
+     */
+    public static void __f_spare(MemorySegment struct, MemorySegment fieldValue) {
+        MemorySegment.copy(fieldValue, 0L, struct, __f_spare$OFFSET, __f_spare$LAYOUT.byteSize());
+    }
+
+    private static long[] __f_spare$DIMS = { 6 };
+
+    /**
+     * Dimensions for array field:
+     * {@snippet lang=c :
+     * int __f_spare[6]
+     * }
+     */
+    public static long[] __f_spare$dimensions() {
+        return __f_spare$DIMS;
+    }
+    private static final VarHandle __f_spare$ELEM_HANDLE = __f_spare$LAYOUT.varHandle(sequenceElement());
+
+    /**
+     * Indexed getter for field:
+     * {@snippet lang=c :
+     * int __f_spare[6]
      * }
      */
-    public static void f_namemax$set(MemorySegment seg, long x) {
-        constants$9.const$4.set(seg, x);
+    public static int __f_spare(MemorySegment struct, long index0) {
+        return (int)__f_spare$ELEM_HANDLE.get(struct, 0L, index0);
     }
-    public static long f_namemax$get(MemorySegment seg, long index) {
-        return (long)constants$9.const$4.get(seg.asSlice(index*sizeof()));
+
+    /**
+     * Indexed setter for field:
+     * {@snippet lang=c :
+     * int __f_spare[6]
+     * }
+     */
+    public static void __f_spare(MemorySegment struct, long index0, int fieldValue) {
+        __f_spare$ELEM_HANDLE.set(struct, 0L, index0, fieldValue);
+    }
+
+    /**
+     * Obtains a slice of {@code arrayParam} which selects the array element at {@code index}.
+     * The returned segment has address {@code arrayParam.address() + index * layout().byteSize()}
+     */
+    public static MemorySegment asSlice(MemorySegment array, long index) {
+        return array.asSlice(layout().byteSize() * index);
+    }
+
+    /**
+     * The size (in bytes) of this struct
+     */
+    public static long sizeof() { return layout().byteSize(); }
+
+    /**
+     * Allocate a segment of size {@code layout().byteSize()} using {@code allocator}
+     */
+    public static MemorySegment allocate(SegmentAllocator allocator) {
+        return allocator.allocate(layout());
     }
-    public static void f_namemax$set(MemorySegment seg, long index, long x) {
-        constants$9.const$4.set(seg.asSlice(index*sizeof()), x);
+
+    /**
+     * Allocate an array of size {@code elementCount} using {@code allocator}.
+     * The returned segment has size {@code elementCount * layout().byteSize()}.
+     */
+    public static MemorySegment allocateArray(long elementCount, SegmentAllocator allocator) {
+        return allocator.allocate(MemoryLayout.sequenceLayout(elementCount, layout()));
     }
-    public static MemorySegment __f_spare$slice(MemorySegment seg) {
-        return seg.asSlice(88, 24);
+
+    /**
+     * Reinterprets {@code addr} using target {@code arena} and {@code cleanupAction) (if any).
+     * The returned segment has size {@code layout().byteSize()}
+     */
+    public static MemorySegment reinterpret(MemorySegment addr, Arena arena, Consumer<MemorySegment> cleanup) {
+        return reinterpret(addr, 1, arena, cleanup);
     }
-    public static long sizeof() { return $LAYOUT().byteSize(); }
-    public static MemorySegment allocate(SegmentAllocator allocator) { return allocator.allocate($LAYOUT()); }
-    public static MemorySegment allocateArray(long len, SegmentAllocator allocator) {
-        return allocator.allocate(MemoryLayout.sequenceLayout(len, $LAYOUT()));
+
+    /**
+     * Reinterprets {@code addr} using target {@code arena} and {@code cleanupAction) (if any).
+     * The returned segment has size {@code elementCount * layout().byteSize()}
+     */
+    public static MemorySegment reinterpret(MemorySegment addr, long elementCount, Arena arena, Consumer<MemorySegment> cleanup) {
+        return addr.reinterpret(layout().byteSize() * elementCount, arena, cleanup);
     }
-    public static MemorySegment ofAddress(MemorySegment addr, Arena scope) { return RuntimeHelper.asArray(addr, $LAYOUT(), 1, scope); }
 }
 
-
diff --git a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/timespec.java b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/timespec.java
index e02fdb57..4b452e62 100644
--- a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/timespec.java
+++ b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3/timespec.java
@@ -2,84 +2,172 @@
 
 package org.cryptomator.jfuse.linux.amd64.extr.fuse3;
 
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
+import java.lang.invoke.*;
 import java.lang.foreign.*;
+import java.nio.ByteOrder;
+import java.util.*;
+import java.util.function.*;
+import java.util.stream.*;
+
 import static java.lang.foreign.ValueLayout.*;
+import static java.lang.foreign.MemoryLayout.PathElement.*;
+
 /**
- * {@snippet :
+ * {@snippet lang=c :
  * struct timespec {
- *     long tv_sec;
- *     long tv_nsec;
- * };
+ *     __time_t tv_sec;
+ *     __syscall_slong_t tv_nsec;
+ * }
  * }
  */
 public class timespec {
 
-    public static MemoryLayout $LAYOUT() {
-        return constants$0.const$4;
+    timespec() {
+        // Should not be called directly
     }
-    public static VarHandle tv_sec$VH() {
-        return constants$0.const$5;
+
+    private static final GroupLayout $LAYOUT = MemoryLayout.structLayout(
+        fuse_h.C_LONG.withName("tv_sec"),
+        fuse_h.C_LONG.withName("tv_nsec")
+    ).withName("timespec");
+
+    /**
+     * The layout of this struct
+     */
+    public static final GroupLayout layout() {
+        return $LAYOUT;
     }
+
+    private static final OfLong tv_sec$LAYOUT = (OfLong)$LAYOUT.select(groupElement("tv_sec"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * __time_t tv_sec
+     * }
+     */
+    public static final OfLong tv_sec$layout() {
+        return tv_sec$LAYOUT;
+    }
+
+    private static final long tv_sec$OFFSET = 0;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * __time_t tv_sec
+     * }
+     */
+    public static final long tv_sec$offset() {
+        return tv_sec$OFFSET;
+    }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * long tv_sec;
+     * {@snippet lang=c :
+     * __time_t tv_sec
      * }
      */
-    public static long tv_sec$get(MemorySegment seg) {
-        return (long)constants$0.const$5.get(seg);
+    public static long tv_sec(MemorySegment struct) {
+        return struct.get(tv_sec$LAYOUT, tv_sec$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * long tv_sec;
+     * {@snippet lang=c :
+     * __time_t tv_sec
      * }
      */
-    public static void tv_sec$set(MemorySegment seg, long x) {
-        constants$0.const$5.set(seg, x);
-    }
-    public static long tv_sec$get(MemorySegment seg, long index) {
-        return (long)constants$0.const$5.get(seg.asSlice(index*sizeof()));
+    public static void tv_sec(MemorySegment struct, long fieldValue) {
+        struct.set(tv_sec$LAYOUT, tv_sec$OFFSET, fieldValue);
     }
-    public static void tv_sec$set(MemorySegment seg, long index, long x) {
-        constants$0.const$5.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfLong tv_nsec$LAYOUT = (OfLong)$LAYOUT.select(groupElement("tv_nsec"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * __syscall_slong_t tv_nsec
+     * }
+     */
+    public static final OfLong tv_nsec$layout() {
+        return tv_nsec$LAYOUT;
     }
-    public static VarHandle tv_nsec$VH() {
-        return constants$1.const$0;
+
+    private static final long tv_nsec$OFFSET = 8;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * __syscall_slong_t tv_nsec
+     * }
+     */
+    public static final long tv_nsec$offset() {
+        return tv_nsec$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * long tv_nsec;
+     * {@snippet lang=c :
+     * __syscall_slong_t tv_nsec
      * }
      */
-    public static long tv_nsec$get(MemorySegment seg) {
-        return (long)constants$1.const$0.get(seg);
+    public static long tv_nsec(MemorySegment struct) {
+        return struct.get(tv_nsec$LAYOUT, tv_nsec$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * long tv_nsec;
+     * {@snippet lang=c :
+     * __syscall_slong_t tv_nsec
      * }
      */
-    public static void tv_nsec$set(MemorySegment seg, long x) {
-        constants$1.const$0.set(seg, x);
+    public static void tv_nsec(MemorySegment struct, long fieldValue) {
+        struct.set(tv_nsec$LAYOUT, tv_nsec$OFFSET, fieldValue);
+    }
+
+    /**
+     * Obtains a slice of {@code arrayParam} which selects the array element at {@code index}.
+     * The returned segment has address {@code arrayParam.address() + index * layout().byteSize()}
+     */
+    public static MemorySegment asSlice(MemorySegment array, long index) {
+        return array.asSlice(layout().byteSize() * index);
+    }
+
+    /**
+     * The size (in bytes) of this struct
+     */
+    public static long sizeof() { return layout().byteSize(); }
+
+    /**
+     * Allocate a segment of size {@code layout().byteSize()} using {@code allocator}
+     */
+    public static MemorySegment allocate(SegmentAllocator allocator) {
+        return allocator.allocate(layout());
     }
-    public static long tv_nsec$get(MemorySegment seg, long index) {
-        return (long)constants$1.const$0.get(seg.asSlice(index*sizeof()));
+
+    /**
+     * Allocate an array of size {@code elementCount} using {@code allocator}.
+     * The returned segment has size {@code elementCount * layout().byteSize()}.
+     */
+    public static MemorySegment allocateArray(long elementCount, SegmentAllocator allocator) {
+        return allocator.allocate(MemoryLayout.sequenceLayout(elementCount, layout()));
     }
-    public static void tv_nsec$set(MemorySegment seg, long index, long x) {
-        constants$1.const$0.set(seg.asSlice(index*sizeof()), x);
+
+    /**
+     * Reinterprets {@code addr} using target {@code arena} and {@code cleanupAction) (if any).
+     * The returned segment has size {@code layout().byteSize()}
+     */
+    public static MemorySegment reinterpret(MemorySegment addr, Arena arena, Consumer<MemorySegment> cleanup) {
+        return reinterpret(addr, 1, arena, cleanup);
     }
-    public static long sizeof() { return $LAYOUT().byteSize(); }
-    public static MemorySegment allocate(SegmentAllocator allocator) { return allocator.allocate($LAYOUT()); }
-    public static MemorySegment allocateArray(long len, SegmentAllocator allocator) {
-        return allocator.allocate(MemoryLayout.sequenceLayout(len, $LAYOUT()));
+
+    /**
+     * Reinterprets {@code addr} using target {@code arena} and {@code cleanupAction) (if any).
+     * The returned segment has size {@code elementCount * layout().byteSize()}
+     */
+    public static MemorySegment reinterpret(MemorySegment addr, long elementCount, Arena arena, Consumer<MemorySegment> cleanup) {
+        return addr.reinterpret(layout().byteSize() * elementCount, arena, cleanup);
     }
-    public static MemorySegment ofAddress(MemorySegment addr, Arena scope) { return RuntimeHelper.asArray(addr, $LAYOUT(), 1, scope); }
 }
 
-
diff --git a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3_lowlevel/RuntimeHelper.java b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3_lowlevel/RuntimeHelper.java
deleted file mode 100644
index a6e405b1..00000000
--- a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3_lowlevel/RuntimeHelper.java
+++ /dev/null
@@ -1,245 +0,0 @@
-package org.cryptomator.jfuse.linux.amd64.extr.fuse3_lowlevel;
-// Generated by jextract
-
-import java.lang.foreign.Linker;
-import java.lang.foreign.FunctionDescriptor;
-import java.lang.foreign.GroupLayout;
-import java.lang.foreign.SymbolLookup;
-import java.lang.foreign.MemoryLayout;
-import java.lang.foreign.MemorySegment;
-import java.lang.foreign.Arena;
-import java.lang.foreign.SegmentAllocator;
-import java.lang.foreign.ValueLayout;
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.MethodHandles;
-import java.lang.invoke.MethodType;
-import java.io.File;
-import java.nio.file.Path;
-import java.nio.charset.StandardCharsets;
-import java.util.Arrays;
-import java.util.Optional;
-import java.util.stream.Stream;
-
-import java.lang.foreign.AddressLayout;
-import java.lang.foreign.MemoryLayout;
-
-import static java.lang.foreign.Linker.*;
-import static java.lang.foreign.ValueLayout.*;
-
-final class RuntimeHelper {
-
-    private static final Linker LINKER = Linker.nativeLinker();
-    private static final ClassLoader LOADER = RuntimeHelper.class.getClassLoader();
-    private static final MethodHandles.Lookup MH_LOOKUP = MethodHandles.lookup();
-    private static final SymbolLookup SYMBOL_LOOKUP;
-    private static final SegmentAllocator THROWING_ALLOCATOR = (x, y) -> { throw new AssertionError("should not reach here"); };
-    static final AddressLayout POINTER = ValueLayout.ADDRESS.withTargetLayout(MemoryLayout.sequenceLayout(JAVA_BYTE));
-
-    final static SegmentAllocator CONSTANT_ALLOCATOR =
-            (size, align) -> Arena.ofAuto().allocate(size, align);
-
-    static {
-        
-        SymbolLookup loaderLookup = SymbolLookup.loaderLookup();
-        SYMBOL_LOOKUP = name -> loaderLookup.find(name).or(() -> LINKER.defaultLookup().find(name));
-    }
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private RuntimeHelper() {}
-
-    static <T> T requireNonNull(T obj, String symbolName) {
-        if (obj == null) {
-            throw new UnsatisfiedLinkError("unresolved symbol: " + symbolName);
-        }
-        return obj;
-    }
-
-    static MemorySegment lookupGlobalVariable(String name, MemoryLayout layout) {
-        return SYMBOL_LOOKUP.find(name)
-                .map(s -> s.reinterpret(layout.byteSize()))
-                .orElse(null);
-    }
-
-    static MethodHandle downcallHandle(String name, FunctionDescriptor fdesc) {
-        return SYMBOL_LOOKUP.find(name).
-                map(addr -> LINKER.downcallHandle(addr, fdesc)).
-                orElse(null);
-    }
-
-    static MethodHandle downcallHandle(FunctionDescriptor fdesc) {
-        return LINKER.downcallHandle(fdesc);
-    }
-
-    static MethodHandle downcallHandleVariadic(String name, FunctionDescriptor fdesc) {
-        return SYMBOL_LOOKUP.find(name).
-                map(addr -> VarargsInvoker.make(addr, fdesc)).
-                orElse(null);
-    }
-
-    static MethodHandle upcallHandle(Class<?> fi, String name, FunctionDescriptor fdesc) {
-        try {
-            return MH_LOOKUP.findVirtual(fi, name, fdesc.toMethodType());
-        } catch (Throwable ex) {
-            throw new AssertionError(ex);
-        }
-    }
-
-    static <Z> MemorySegment upcallStub(MethodHandle fiHandle, Z z, FunctionDescriptor fdesc, Arena scope) {
-        try {
-            fiHandle = fiHandle.bindTo(z);
-            return LINKER.upcallStub(fiHandle, fdesc, scope);
-        } catch (Throwable ex) {
-            throw new AssertionError(ex);
-        }
-    }
-
-    static MemorySegment asArray(MemorySegment addr, MemoryLayout layout, int numElements, Arena arena) {
-         return addr.reinterpret(numElements * layout.byteSize(), arena, null);
-    }
-
-    // Internals only below this point
-
-    private static final class VarargsInvoker {
-        private static final MethodHandle INVOKE_MH;
-        private final MemorySegment symbol;
-        private final FunctionDescriptor function;
-
-        private VarargsInvoker(MemorySegment symbol, FunctionDescriptor function) {
-            this.symbol = symbol;
-            this.function = function;
-        }
-
-        static {
-            try {
-                INVOKE_MH = MethodHandles.lookup().findVirtual(VarargsInvoker.class, "invoke", MethodType.methodType(Object.class, SegmentAllocator.class, Object[].class));
-            } catch (ReflectiveOperationException e) {
-                throw new RuntimeException(e);
-            }
-        }
-
-        static MethodHandle make(MemorySegment symbol, FunctionDescriptor function) {
-            VarargsInvoker invoker = new VarargsInvoker(symbol, function);
-            MethodHandle handle = INVOKE_MH.bindTo(invoker).asCollector(Object[].class, function.argumentLayouts().size() + 1);
-            MethodType mtype = MethodType.methodType(function.returnLayout().isPresent() ? carrier(function.returnLayout().get(), true) : void.class);
-            for (MemoryLayout layout : function.argumentLayouts()) {
-                mtype = mtype.appendParameterTypes(carrier(layout, false));
-            }
-            mtype = mtype.appendParameterTypes(Object[].class);
-            boolean needsAllocator = function.returnLayout().isPresent() &&
-                                function.returnLayout().get() instanceof GroupLayout;
-            if (needsAllocator) {
-                mtype = mtype.insertParameterTypes(0, SegmentAllocator.class);
-            } else {
-                handle = MethodHandles.insertArguments(handle, 0, THROWING_ALLOCATOR);
-            }
-            return handle.asType(mtype);
-        }
-
-        static Class<?> carrier(MemoryLayout layout, boolean ret) {
-            if (layout instanceof ValueLayout valueLayout) {
-                return valueLayout.carrier();
-            } else if (layout instanceof GroupLayout) {
-                return MemorySegment.class;
-            } else {
-                throw new AssertionError("Cannot get here!");
-            }
-        }
-
-        private Object invoke(SegmentAllocator allocator, Object[] args) throws Throwable {
-            // one trailing Object[]
-            int nNamedArgs = function.argumentLayouts().size();
-            assert(args.length == nNamedArgs + 1);
-            // The last argument is the array of vararg collector
-            Object[] unnamedArgs = (Object[]) args[args.length - 1];
-
-            int argsCount = nNamedArgs + unnamedArgs.length;
-            Class<?>[] argTypes = new Class<?>[argsCount];
-            MemoryLayout[] argLayouts = new MemoryLayout[nNamedArgs + unnamedArgs.length];
-
-            int pos = 0;
-            for (pos = 0; pos < nNamedArgs; pos++) {
-                argLayouts[pos] = function.argumentLayouts().get(pos);
-            }
-
-            assert pos == nNamedArgs;
-            for (Object o: unnamedArgs) {
-                argLayouts[pos] = variadicLayout(normalize(o.getClass()));
-                pos++;
-            }
-            assert pos == argsCount;
-
-            FunctionDescriptor f = (function.returnLayout().isEmpty()) ?
-                    FunctionDescriptor.ofVoid(argLayouts) :
-                    FunctionDescriptor.of(function.returnLayout().get(), argLayouts);
-            MethodHandle mh = LINKER.downcallHandle(symbol, f);
-            boolean needsAllocator = function.returnLayout().isPresent() &&
-                                            function.returnLayout().get() instanceof GroupLayout;
-            if (needsAllocator) {
-                mh = mh.bindTo(allocator);
-            }
-            // flatten argument list so that it can be passed to an asSpreader MH
-            Object[] allArgs = new Object[nNamedArgs + unnamedArgs.length];
-            System.arraycopy(args, 0, allArgs, 0, nNamedArgs);
-            System.arraycopy(unnamedArgs, 0, allArgs, nNamedArgs, unnamedArgs.length);
-
-            return mh.asSpreader(Object[].class, argsCount).invoke(allArgs);
-        }
-
-        private static Class<?> unboxIfNeeded(Class<?> clazz) {
-            if (clazz == Boolean.class) {
-                return boolean.class;
-            } else if (clazz == Void.class) {
-                return void.class;
-            } else if (clazz == Byte.class) {
-                return byte.class;
-            } else if (clazz == Character.class) {
-                return char.class;
-            } else if (clazz == Short.class) {
-                return short.class;
-            } else if (clazz == Integer.class) {
-                return int.class;
-            } else if (clazz == Long.class) {
-                return long.class;
-            } else if (clazz == Float.class) {
-                return float.class;
-            } else if (clazz == Double.class) {
-                return double.class;
-            } else {
-                return clazz;
-            }
-        }
-
-        private Class<?> promote(Class<?> c) {
-            if (c == byte.class || c == char.class || c == short.class || c == int.class) {
-                return long.class;
-            } else if (c == float.class) {
-                return double.class;
-            } else {
-                return c;
-            }
-        }
-
-        private Class<?> normalize(Class<?> c) {
-            c = unboxIfNeeded(c);
-            if (c.isPrimitive()) {
-                return promote(c);
-            }
-            if (c == MemorySegment.class) {
-                return MemorySegment.class;
-            }
-            throw new IllegalArgumentException("Invalid type for ABI: " + c.getTypeName());
-        }
-
-        private MemoryLayout variadicLayout(Class<?> c) {
-            if (c == long.class) {
-                return JAVA_LONG;
-            } else if (c == double.class) {
-                return JAVA_DOUBLE;
-            } else if (c == MemorySegment.class) {
-                return ADDRESS;
-            } else {
-                throw new IllegalArgumentException("Unhandled variadic argument class: " + c);
-            }
-        }
-    }
-}
diff --git a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3_lowlevel/constants$0.java b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3_lowlevel/constants$0.java
deleted file mode 100644
index 88d8ae32..00000000
--- a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3_lowlevel/constants$0.java
+++ /dev/null
@@ -1,34 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.linux.amd64.extr.fuse3_lowlevel;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$0 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$0() {}
-    static final StructLayout const$0 = MemoryLayout.structLayout(
-        JAVA_INT.withName("singlethread"),
-        JAVA_INT.withName("foreground"),
-        JAVA_INT.withName("debug"),
-        JAVA_INT.withName("nodefault_subtype"),
-        RuntimeHelper.POINTER.withName("mountpoint"),
-        JAVA_INT.withName("show_version"),
-        JAVA_INT.withName("show_help"),
-        JAVA_INT.withName("clone_fd"),
-        JAVA_INT.withName("max_idle_threads"),
-        JAVA_INT.withName("max_threads"),
-        MemoryLayout.paddingLayout(4)
-    ).withName("fuse_cmdline_opts");
-    static final VarHandle const$1 = constants$0.const$0.varHandle(MemoryLayout.PathElement.groupElement("singlethread"));
-    static final VarHandle const$2 = constants$0.const$0.varHandle(MemoryLayout.PathElement.groupElement("foreground"));
-    static final VarHandle const$3 = constants$0.const$0.varHandle(MemoryLayout.PathElement.groupElement("debug"));
-    static final VarHandle const$4 = constants$0.const$0.varHandle(MemoryLayout.PathElement.groupElement("nodefault_subtype"));
-    static final VarHandle const$5 = constants$0.const$0.varHandle(MemoryLayout.PathElement.groupElement("mountpoint"));
-}
-
-
diff --git a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3_lowlevel/constants$1.java b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3_lowlevel/constants$1.java
deleted file mode 100644
index 2af20545..00000000
--- a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3_lowlevel/constants$1.java
+++ /dev/null
@@ -1,21 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.linux.amd64.extr.fuse3_lowlevel;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$1 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$1() {}
-    static final VarHandle const$0 = constants$0.const$0.varHandle(MemoryLayout.PathElement.groupElement("show_version"));
-    static final VarHandle const$1 = constants$0.const$0.varHandle(MemoryLayout.PathElement.groupElement("show_help"));
-    static final VarHandle const$2 = constants$0.const$0.varHandle(MemoryLayout.PathElement.groupElement("clone_fd"));
-    static final VarHandle const$3 = constants$0.const$0.varHandle(MemoryLayout.PathElement.groupElement("max_idle_threads"));
-    static final VarHandle const$4 = constants$0.const$0.varHandle(MemoryLayout.PathElement.groupElement("max_threads"));
-}
-
-
diff --git a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3_lowlevel/fuse_cmdline_opts.java b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3_lowlevel/fuse_cmdline_opts.java
index 872bda74..0748c9f0 100644
--- a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3_lowlevel/fuse_cmdline_opts.java
+++ b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3_lowlevel/fuse_cmdline_opts.java
@@ -2,308 +2,541 @@
 
 package org.cryptomator.jfuse.linux.amd64.extr.fuse3_lowlevel;
 
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
+import java.lang.invoke.*;
 import java.lang.foreign.*;
+import java.nio.ByteOrder;
+import java.util.*;
+import java.util.function.*;
+import java.util.stream.*;
+
 import static java.lang.foreign.ValueLayout.*;
+import static java.lang.foreign.MemoryLayout.PathElement.*;
+
 /**
- * {@snippet :
+ * {@snippet lang=c :
  * struct fuse_cmdline_opts {
  *     int singlethread;
  *     int foreground;
  *     int debug;
  *     int nodefault_subtype;
- *     char* mountpoint;
+ *     char *mountpoint;
  *     int show_version;
  *     int show_help;
  *     int clone_fd;
  *     unsigned int max_idle_threads;
  *     unsigned int max_threads;
- * };
+ * }
  * }
  */
 public class fuse_cmdline_opts {
 
-    public static MemoryLayout $LAYOUT() {
-        return constants$0.const$0;
+    fuse_cmdline_opts() {
+        // Should not be called directly
     }
-    public static VarHandle singlethread$VH() {
-        return constants$0.const$1;
+
+    private static final GroupLayout $LAYOUT = MemoryLayout.structLayout(
+        fuse_lowlevel_h.C_INT.withName("singlethread"),
+        fuse_lowlevel_h.C_INT.withName("foreground"),
+        fuse_lowlevel_h.C_INT.withName("debug"),
+        fuse_lowlevel_h.C_INT.withName("nodefault_subtype"),
+        fuse_lowlevel_h.C_POINTER.withName("mountpoint"),
+        fuse_lowlevel_h.C_INT.withName("show_version"),
+        fuse_lowlevel_h.C_INT.withName("show_help"),
+        fuse_lowlevel_h.C_INT.withName("clone_fd"),
+        fuse_lowlevel_h.C_INT.withName("max_idle_threads"),
+        fuse_lowlevel_h.C_INT.withName("max_threads"),
+        MemoryLayout.paddingLayout(4)
+    ).withName("fuse_cmdline_opts");
+
+    /**
+     * The layout of this struct
+     */
+    public static final GroupLayout layout() {
+        return $LAYOUT;
     }
+
+    private static final OfInt singlethread$LAYOUT = (OfInt)$LAYOUT.select(groupElement("singlethread"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int singlethread
+     * }
+     */
+    public static final OfInt singlethread$layout() {
+        return singlethread$LAYOUT;
+    }
+
+    private static final long singlethread$OFFSET = 0;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int singlethread
+     * }
+     */
+    public static final long singlethread$offset() {
+        return singlethread$OFFSET;
+    }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int singlethread;
+     * {@snippet lang=c :
+     * int singlethread
      * }
      */
-    public static int singlethread$get(MemorySegment seg) {
-        return (int)constants$0.const$1.get(seg);
+    public static int singlethread(MemorySegment struct) {
+        return struct.get(singlethread$LAYOUT, singlethread$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int singlethread;
+     * {@snippet lang=c :
+     * int singlethread
      * }
      */
-    public static void singlethread$set(MemorySegment seg, int x) {
-        constants$0.const$1.set(seg, x);
-    }
-    public static int singlethread$get(MemorySegment seg, long index) {
-        return (int)constants$0.const$1.get(seg.asSlice(index*sizeof()));
+    public static void singlethread(MemorySegment struct, int fieldValue) {
+        struct.set(singlethread$LAYOUT, singlethread$OFFSET, fieldValue);
     }
-    public static void singlethread$set(MemorySegment seg, long index, int x) {
-        constants$0.const$1.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt foreground$LAYOUT = (OfInt)$LAYOUT.select(groupElement("foreground"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int foreground
+     * }
+     */
+    public static final OfInt foreground$layout() {
+        return foreground$LAYOUT;
     }
-    public static VarHandle foreground$VH() {
-        return constants$0.const$2;
+
+    private static final long foreground$OFFSET = 4;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int foreground
+     * }
+     */
+    public static final long foreground$offset() {
+        return foreground$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int foreground;
+     * {@snippet lang=c :
+     * int foreground
      * }
      */
-    public static int foreground$get(MemorySegment seg) {
-        return (int)constants$0.const$2.get(seg);
+    public static int foreground(MemorySegment struct) {
+        return struct.get(foreground$LAYOUT, foreground$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int foreground;
+     * {@snippet lang=c :
+     * int foreground
      * }
      */
-    public static void foreground$set(MemorySegment seg, int x) {
-        constants$0.const$2.set(seg, x);
+    public static void foreground(MemorySegment struct, int fieldValue) {
+        struct.set(foreground$LAYOUT, foreground$OFFSET, fieldValue);
     }
-    public static int foreground$get(MemorySegment seg, long index) {
-        return (int)constants$0.const$2.get(seg.asSlice(index*sizeof()));
-    }
-    public static void foreground$set(MemorySegment seg, long index, int x) {
-        constants$0.const$2.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt debug$LAYOUT = (OfInt)$LAYOUT.select(groupElement("debug"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int debug
+     * }
+     */
+    public static final OfInt debug$layout() {
+        return debug$LAYOUT;
     }
-    public static VarHandle debug$VH() {
-        return constants$0.const$3;
+
+    private static final long debug$OFFSET = 8;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int debug
+     * }
+     */
+    public static final long debug$offset() {
+        return debug$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int debug;
+     * {@snippet lang=c :
+     * int debug
      * }
      */
-    public static int debug$get(MemorySegment seg) {
-        return (int)constants$0.const$3.get(seg);
+    public static int debug(MemorySegment struct) {
+        return struct.get(debug$LAYOUT, debug$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int debug;
+     * {@snippet lang=c :
+     * int debug
      * }
      */
-    public static void debug$set(MemorySegment seg, int x) {
-        constants$0.const$3.set(seg, x);
+    public static void debug(MemorySegment struct, int fieldValue) {
+        struct.set(debug$LAYOUT, debug$OFFSET, fieldValue);
     }
-    public static int debug$get(MemorySegment seg, long index) {
-        return (int)constants$0.const$3.get(seg.asSlice(index*sizeof()));
-    }
-    public static void debug$set(MemorySegment seg, long index, int x) {
-        constants$0.const$3.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt nodefault_subtype$LAYOUT = (OfInt)$LAYOUT.select(groupElement("nodefault_subtype"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int nodefault_subtype
+     * }
+     */
+    public static final OfInt nodefault_subtype$layout() {
+        return nodefault_subtype$LAYOUT;
     }
-    public static VarHandle nodefault_subtype$VH() {
-        return constants$0.const$4;
+
+    private static final long nodefault_subtype$OFFSET = 12;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int nodefault_subtype
+     * }
+     */
+    public static final long nodefault_subtype$offset() {
+        return nodefault_subtype$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int nodefault_subtype;
+     * {@snippet lang=c :
+     * int nodefault_subtype
      * }
      */
-    public static int nodefault_subtype$get(MemorySegment seg) {
-        return (int)constants$0.const$4.get(seg);
+    public static int nodefault_subtype(MemorySegment struct) {
+        return struct.get(nodefault_subtype$LAYOUT, nodefault_subtype$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int nodefault_subtype;
+     * {@snippet lang=c :
+     * int nodefault_subtype
      * }
      */
-    public static void nodefault_subtype$set(MemorySegment seg, int x) {
-        constants$0.const$4.set(seg, x);
-    }
-    public static int nodefault_subtype$get(MemorySegment seg, long index) {
-        return (int)constants$0.const$4.get(seg.asSlice(index*sizeof()));
+    public static void nodefault_subtype(MemorySegment struct, int fieldValue) {
+        struct.set(nodefault_subtype$LAYOUT, nodefault_subtype$OFFSET, fieldValue);
     }
-    public static void nodefault_subtype$set(MemorySegment seg, long index, int x) {
-        constants$0.const$4.set(seg.asSlice(index*sizeof()), x);
+
+    private static final AddressLayout mountpoint$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("mountpoint"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * char *mountpoint
+     * }
+     */
+    public static final AddressLayout mountpoint$layout() {
+        return mountpoint$LAYOUT;
     }
-    public static VarHandle mountpoint$VH() {
-        return constants$0.const$5;
+
+    private static final long mountpoint$OFFSET = 16;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * char *mountpoint
+     * }
+     */
+    public static final long mountpoint$offset() {
+        return mountpoint$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * char* mountpoint;
+     * {@snippet lang=c :
+     * char *mountpoint
      * }
      */
-    public static MemorySegment mountpoint$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$0.const$5.get(seg);
+    public static MemorySegment mountpoint(MemorySegment struct) {
+        return struct.get(mountpoint$LAYOUT, mountpoint$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * char* mountpoint;
+     * {@snippet lang=c :
+     * char *mountpoint
      * }
      */
-    public static void mountpoint$set(MemorySegment seg, MemorySegment x) {
-        constants$0.const$5.set(seg, x);
-    }
-    public static MemorySegment mountpoint$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$0.const$5.get(seg.asSlice(index*sizeof()));
+    public static void mountpoint(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(mountpoint$LAYOUT, mountpoint$OFFSET, fieldValue);
     }
-    public static void mountpoint$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$0.const$5.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt show_version$LAYOUT = (OfInt)$LAYOUT.select(groupElement("show_version"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int show_version
+     * }
+     */
+    public static final OfInt show_version$layout() {
+        return show_version$LAYOUT;
     }
-    public static VarHandle show_version$VH() {
-        return constants$1.const$0;
+
+    private static final long show_version$OFFSET = 24;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int show_version
+     * }
+     */
+    public static final long show_version$offset() {
+        return show_version$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int show_version;
+     * {@snippet lang=c :
+     * int show_version
      * }
      */
-    public static int show_version$get(MemorySegment seg) {
-        return (int)constants$1.const$0.get(seg);
+    public static int show_version(MemorySegment struct) {
+        return struct.get(show_version$LAYOUT, show_version$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int show_version;
+     * {@snippet lang=c :
+     * int show_version
      * }
      */
-    public static void show_version$set(MemorySegment seg, int x) {
-        constants$1.const$0.set(seg, x);
-    }
-    public static int show_version$get(MemorySegment seg, long index) {
-        return (int)constants$1.const$0.get(seg.asSlice(index*sizeof()));
+    public static void show_version(MemorySegment struct, int fieldValue) {
+        struct.set(show_version$LAYOUT, show_version$OFFSET, fieldValue);
     }
-    public static void show_version$set(MemorySegment seg, long index, int x) {
-        constants$1.const$0.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt show_help$LAYOUT = (OfInt)$LAYOUT.select(groupElement("show_help"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int show_help
+     * }
+     */
+    public static final OfInt show_help$layout() {
+        return show_help$LAYOUT;
     }
-    public static VarHandle show_help$VH() {
-        return constants$1.const$1;
+
+    private static final long show_help$OFFSET = 28;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int show_help
+     * }
+     */
+    public static final long show_help$offset() {
+        return show_help$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int show_help;
+     * {@snippet lang=c :
+     * int show_help
      * }
      */
-    public static int show_help$get(MemorySegment seg) {
-        return (int)constants$1.const$1.get(seg);
+    public static int show_help(MemorySegment struct) {
+        return struct.get(show_help$LAYOUT, show_help$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int show_help;
+     * {@snippet lang=c :
+     * int show_help
      * }
      */
-    public static void show_help$set(MemorySegment seg, int x) {
-        constants$1.const$1.set(seg, x);
+    public static void show_help(MemorySegment struct, int fieldValue) {
+        struct.set(show_help$LAYOUT, show_help$OFFSET, fieldValue);
     }
-    public static int show_help$get(MemorySegment seg, long index) {
-        return (int)constants$1.const$1.get(seg.asSlice(index*sizeof()));
-    }
-    public static void show_help$set(MemorySegment seg, long index, int x) {
-        constants$1.const$1.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt clone_fd$LAYOUT = (OfInt)$LAYOUT.select(groupElement("clone_fd"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int clone_fd
+     * }
+     */
+    public static final OfInt clone_fd$layout() {
+        return clone_fd$LAYOUT;
     }
-    public static VarHandle clone_fd$VH() {
-        return constants$1.const$2;
+
+    private static final long clone_fd$OFFSET = 32;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int clone_fd
+     * }
+     */
+    public static final long clone_fd$offset() {
+        return clone_fd$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int clone_fd;
+     * {@snippet lang=c :
+     * int clone_fd
      * }
      */
-    public static int clone_fd$get(MemorySegment seg) {
-        return (int)constants$1.const$2.get(seg);
+    public static int clone_fd(MemorySegment struct) {
+        return struct.get(clone_fd$LAYOUT, clone_fd$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int clone_fd;
+     * {@snippet lang=c :
+     * int clone_fd
      * }
      */
-    public static void clone_fd$set(MemorySegment seg, int x) {
-        constants$1.const$2.set(seg, x);
+    public static void clone_fd(MemorySegment struct, int fieldValue) {
+        struct.set(clone_fd$LAYOUT, clone_fd$OFFSET, fieldValue);
     }
-    public static int clone_fd$get(MemorySegment seg, long index) {
-        return (int)constants$1.const$2.get(seg.asSlice(index*sizeof()));
-    }
-    public static void clone_fd$set(MemorySegment seg, long index, int x) {
-        constants$1.const$2.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt max_idle_threads$LAYOUT = (OfInt)$LAYOUT.select(groupElement("max_idle_threads"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * unsigned int max_idle_threads
+     * }
+     */
+    public static final OfInt max_idle_threads$layout() {
+        return max_idle_threads$LAYOUT;
     }
-    public static VarHandle max_idle_threads$VH() {
-        return constants$1.const$3;
+
+    private static final long max_idle_threads$OFFSET = 36;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * unsigned int max_idle_threads
+     * }
+     */
+    public static final long max_idle_threads$offset() {
+        return max_idle_threads$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned int max_idle_threads;
+     * {@snippet lang=c :
+     * unsigned int max_idle_threads
      * }
      */
-    public static int max_idle_threads$get(MemorySegment seg) {
-        return (int)constants$1.const$3.get(seg);
+    public static int max_idle_threads(MemorySegment struct) {
+        return struct.get(max_idle_threads$LAYOUT, max_idle_threads$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned int max_idle_threads;
+     * {@snippet lang=c :
+     * unsigned int max_idle_threads
      * }
      */
-    public static void max_idle_threads$set(MemorySegment seg, int x) {
-        constants$1.const$3.set(seg, x);
-    }
-    public static int max_idle_threads$get(MemorySegment seg, long index) {
-        return (int)constants$1.const$3.get(seg.asSlice(index*sizeof()));
+    public static void max_idle_threads(MemorySegment struct, int fieldValue) {
+        struct.set(max_idle_threads$LAYOUT, max_idle_threads$OFFSET, fieldValue);
     }
-    public static void max_idle_threads$set(MemorySegment seg, long index, int x) {
-        constants$1.const$3.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt max_threads$LAYOUT = (OfInt)$LAYOUT.select(groupElement("max_threads"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * unsigned int max_threads
+     * }
+     */
+    public static final OfInt max_threads$layout() {
+        return max_threads$LAYOUT;
     }
-    public static VarHandle max_threads$VH() {
-        return constants$1.const$4;
+
+    private static final long max_threads$OFFSET = 40;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * unsigned int max_threads
+     * }
+     */
+    public static final long max_threads$offset() {
+        return max_threads$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned int max_threads;
+     * {@snippet lang=c :
+     * unsigned int max_threads
      * }
      */
-    public static int max_threads$get(MemorySegment seg) {
-        return (int)constants$1.const$4.get(seg);
+    public static int max_threads(MemorySegment struct) {
+        return struct.get(max_threads$LAYOUT, max_threads$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned int max_threads;
+     * {@snippet lang=c :
+     * unsigned int max_threads
      * }
      */
-    public static void max_threads$set(MemorySegment seg, int x) {
-        constants$1.const$4.set(seg, x);
+    public static void max_threads(MemorySegment struct, int fieldValue) {
+        struct.set(max_threads$LAYOUT, max_threads$OFFSET, fieldValue);
+    }
+
+    /**
+     * Obtains a slice of {@code arrayParam} which selects the array element at {@code index}.
+     * The returned segment has address {@code arrayParam.address() + index * layout().byteSize()}
+     */
+    public static MemorySegment asSlice(MemorySegment array, long index) {
+        return array.asSlice(layout().byteSize() * index);
+    }
+
+    /**
+     * The size (in bytes) of this struct
+     */
+    public static long sizeof() { return layout().byteSize(); }
+
+    /**
+     * Allocate a segment of size {@code layout().byteSize()} using {@code allocator}
+     */
+    public static MemorySegment allocate(SegmentAllocator allocator) {
+        return allocator.allocate(layout());
     }
-    public static int max_threads$get(MemorySegment seg, long index) {
-        return (int)constants$1.const$4.get(seg.asSlice(index*sizeof()));
+
+    /**
+     * Allocate an array of size {@code elementCount} using {@code allocator}.
+     * The returned segment has size {@code elementCount * layout().byteSize()}.
+     */
+    public static MemorySegment allocateArray(long elementCount, SegmentAllocator allocator) {
+        return allocator.allocate(MemoryLayout.sequenceLayout(elementCount, layout()));
     }
-    public static void max_threads$set(MemorySegment seg, long index, int x) {
-        constants$1.const$4.set(seg.asSlice(index*sizeof()), x);
+
+    /**
+     * Reinterprets {@code addr} using target {@code arena} and {@code cleanupAction) (if any).
+     * The returned segment has size {@code layout().byteSize()}
+     */
+    public static MemorySegment reinterpret(MemorySegment addr, Arena arena, Consumer<MemorySegment> cleanup) {
+        return reinterpret(addr, 1, arena, cleanup);
     }
-    public static long sizeof() { return $LAYOUT().byteSize(); }
-    public static MemorySegment allocate(SegmentAllocator allocator) { return allocator.allocate($LAYOUT()); }
-    public static MemorySegment allocateArray(long len, SegmentAllocator allocator) {
-        return allocator.allocate(MemoryLayout.sequenceLayout(len, $LAYOUT()));
+
+    /**
+     * Reinterprets {@code addr} using target {@code arena} and {@code cleanupAction) (if any).
+     * The returned segment has size {@code elementCount * layout().byteSize()}
+     */
+    public static MemorySegment reinterpret(MemorySegment addr, long elementCount, Arena arena, Consumer<MemorySegment> cleanup) {
+        return addr.reinterpret(layout().byteSize() * elementCount, arena, cleanup);
     }
-    public static MemorySegment ofAddress(MemorySegment addr, Arena scope) { return RuntimeHelper.asArray(addr, $LAYOUT(), 1, scope); }
 }
 
-
diff --git a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3_lowlevel/fuse_lowlevel_h.java b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3_lowlevel/fuse_lowlevel_h.java
index 03df7411..79e666df 100644
--- a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3_lowlevel/fuse_lowlevel_h.java
+++ b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse3_lowlevel/fuse_lowlevel_h.java
@@ -2,21 +2,71 @@
 
 package org.cryptomator.jfuse.linux.amd64.extr.fuse3_lowlevel;
 
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
+import java.lang.invoke.*;
 import java.lang.foreign.*;
+import java.nio.ByteOrder;
+import java.util.*;
+import java.util.function.*;
+import java.util.stream.*;
+
 import static java.lang.foreign.ValueLayout.*;
-public class fuse_lowlevel_h  {
-
-    public static final OfByte C_CHAR = JAVA_BYTE;
-    public static final OfShort C_SHORT = JAVA_SHORT;
-    public static final OfInt C_INT = JAVA_INT;
-    public static final OfLong C_LONG = JAVA_LONG;
-    public static final OfLong C_LONG_LONG = JAVA_LONG;
-    public static final OfFloat C_FLOAT = JAVA_FLOAT;
-    public static final OfDouble C_DOUBLE = JAVA_DOUBLE;
-    public static final AddressLayout C_POINTER = RuntimeHelper.POINTER;
-}
+import static java.lang.foreign.MemoryLayout.PathElement.*;
+
+public class fuse_lowlevel_h {
+
+    fuse_lowlevel_h() {
+        // Should not be called directly
+    }
+
+    static final Arena LIBRARY_ARENA = Arena.ofAuto();
+    static final boolean TRACE_DOWNCALLS = Boolean.getBoolean("jextract.trace.downcalls");
 
+    static void traceDowncall(String name, Object... args) {
+         String traceArgs = Arrays.stream(args)
+                       .map(Object::toString)
+                       .collect(Collectors.joining(", "));
+         System.out.printf("%s(%s)\n", name, traceArgs);
+    }
+
+    static MemorySegment findOrThrow(String symbol) {
+        return SYMBOL_LOOKUP.find(symbol)
+            .orElseThrow(() -> new UnsatisfiedLinkError("unresolved symbol: " + symbol));
+    }
+
+    static MethodHandle upcallHandle(Class<?> fi, String name, FunctionDescriptor fdesc) {
+        try {
+            return MethodHandles.lookup().findVirtual(fi, name, fdesc.toMethodType());
+        } catch (ReflectiveOperationException ex) {
+            throw new AssertionError(ex);
+        }
+    }
+
+    static MemoryLayout align(MemoryLayout layout, long align) {
+        return switch (layout) {
+            case PaddingLayout p -> p;
+            case ValueLayout v -> v.withByteAlignment(align);
+            case GroupLayout g -> {
+                MemoryLayout[] alignedMembers = g.memberLayouts().stream()
+                        .map(m -> align(m, align)).toArray(MemoryLayout[]::new);
+                yield g instanceof StructLayout ?
+                        MemoryLayout.structLayout(alignedMembers) : MemoryLayout.unionLayout(alignedMembers);
+            }
+            case SequenceLayout s -> MemoryLayout.sequenceLayout(s.elementCount(), align(s.elementLayout(), align));
+        };
+    }
+
+    static final SymbolLookup SYMBOL_LOOKUP = SymbolLookup.loaderLookup()
+            .or(Linker.nativeLinker().defaultLookup());
+
+    public static final ValueLayout.OfBoolean C_BOOL = ValueLayout.JAVA_BOOLEAN;
+    public static final ValueLayout.OfByte C_CHAR = ValueLayout.JAVA_BYTE;
+    public static final ValueLayout.OfShort C_SHORT = ValueLayout.JAVA_SHORT;
+    public static final ValueLayout.OfInt C_INT = ValueLayout.JAVA_INT;
+    public static final ValueLayout.OfLong C_LONG_LONG = ValueLayout.JAVA_LONG;
+    public static final ValueLayout.OfFloat C_FLOAT = ValueLayout.JAVA_FLOAT;
+    public static final ValueLayout.OfDouble C_DOUBLE = ValueLayout.JAVA_DOUBLE;
+    public static final AddressLayout C_POINTER = ValueLayout.ADDRESS
+            .withTargetLayout(MemoryLayout.sequenceLayout(java.lang.Long.MAX_VALUE, JAVA_BYTE));
+    public static final ValueLayout.OfLong C_LONG = ValueLayout.JAVA_LONG;
+}
 
diff --git a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/stat/RuntimeHelper.java b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/stat/RuntimeHelper.java
deleted file mode 100644
index 3fe963f3..00000000
--- a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/stat/RuntimeHelper.java
+++ /dev/null
@@ -1,245 +0,0 @@
-package org.cryptomator.jfuse.linux.amd64.extr.stat;
-// Generated by jextract
-
-import java.lang.foreign.Linker;
-import java.lang.foreign.FunctionDescriptor;
-import java.lang.foreign.GroupLayout;
-import java.lang.foreign.SymbolLookup;
-import java.lang.foreign.MemoryLayout;
-import java.lang.foreign.MemorySegment;
-import java.lang.foreign.Arena;
-import java.lang.foreign.SegmentAllocator;
-import java.lang.foreign.ValueLayout;
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.MethodHandles;
-import java.lang.invoke.MethodType;
-import java.io.File;
-import java.nio.file.Path;
-import java.nio.charset.StandardCharsets;
-import java.util.Arrays;
-import java.util.Optional;
-import java.util.stream.Stream;
-
-import java.lang.foreign.AddressLayout;
-import java.lang.foreign.MemoryLayout;
-
-import static java.lang.foreign.Linker.*;
-import static java.lang.foreign.ValueLayout.*;
-
-final class RuntimeHelper {
-
-    private static final Linker LINKER = Linker.nativeLinker();
-    private static final ClassLoader LOADER = RuntimeHelper.class.getClassLoader();
-    private static final MethodHandles.Lookup MH_LOOKUP = MethodHandles.lookup();
-    private static final SymbolLookup SYMBOL_LOOKUP;
-    private static final SegmentAllocator THROWING_ALLOCATOR = (x, y) -> { throw new AssertionError("should not reach here"); };
-    static final AddressLayout POINTER = ValueLayout.ADDRESS.withTargetLayout(MemoryLayout.sequenceLayout(JAVA_BYTE));
-
-    final static SegmentAllocator CONSTANT_ALLOCATOR =
-            (size, align) -> Arena.ofAuto().allocate(size, align);
-
-    static {
-        
-        SymbolLookup loaderLookup = SymbolLookup.loaderLookup();
-        SYMBOL_LOOKUP = name -> loaderLookup.find(name).or(() -> LINKER.defaultLookup().find(name));
-    }
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private RuntimeHelper() {}
-
-    static <T> T requireNonNull(T obj, String symbolName) {
-        if (obj == null) {
-            throw new UnsatisfiedLinkError("unresolved symbol: " + symbolName);
-        }
-        return obj;
-    }
-
-    static MemorySegment lookupGlobalVariable(String name, MemoryLayout layout) {
-        return SYMBOL_LOOKUP.find(name)
-                .map(s -> s.reinterpret(layout.byteSize()))
-                .orElse(null);
-    }
-
-    static MethodHandle downcallHandle(String name, FunctionDescriptor fdesc) {
-        return SYMBOL_LOOKUP.find(name).
-                map(addr -> LINKER.downcallHandle(addr, fdesc)).
-                orElse(null);
-    }
-
-    static MethodHandle downcallHandle(FunctionDescriptor fdesc) {
-        return LINKER.downcallHandle(fdesc);
-    }
-
-    static MethodHandle downcallHandleVariadic(String name, FunctionDescriptor fdesc) {
-        return SYMBOL_LOOKUP.find(name).
-                map(addr -> VarargsInvoker.make(addr, fdesc)).
-                orElse(null);
-    }
-
-    static MethodHandle upcallHandle(Class<?> fi, String name, FunctionDescriptor fdesc) {
-        try {
-            return MH_LOOKUP.findVirtual(fi, name, fdesc.toMethodType());
-        } catch (Throwable ex) {
-            throw new AssertionError(ex);
-        }
-    }
-
-    static <Z> MemorySegment upcallStub(MethodHandle fiHandle, Z z, FunctionDescriptor fdesc, Arena scope) {
-        try {
-            fiHandle = fiHandle.bindTo(z);
-            return LINKER.upcallStub(fiHandle, fdesc, scope);
-        } catch (Throwable ex) {
-            throw new AssertionError(ex);
-        }
-    }
-
-    static MemorySegment asArray(MemorySegment addr, MemoryLayout layout, int numElements, Arena arena) {
-         return addr.reinterpret(numElements * layout.byteSize(), arena, null);
-    }
-
-    // Internals only below this point
-
-    private static final class VarargsInvoker {
-        private static final MethodHandle INVOKE_MH;
-        private final MemorySegment symbol;
-        private final FunctionDescriptor function;
-
-        private VarargsInvoker(MemorySegment symbol, FunctionDescriptor function) {
-            this.symbol = symbol;
-            this.function = function;
-        }
-
-        static {
-            try {
-                INVOKE_MH = MethodHandles.lookup().findVirtual(VarargsInvoker.class, "invoke", MethodType.methodType(Object.class, SegmentAllocator.class, Object[].class));
-            } catch (ReflectiveOperationException e) {
-                throw new RuntimeException(e);
-            }
-        }
-
-        static MethodHandle make(MemorySegment symbol, FunctionDescriptor function) {
-            VarargsInvoker invoker = new VarargsInvoker(symbol, function);
-            MethodHandle handle = INVOKE_MH.bindTo(invoker).asCollector(Object[].class, function.argumentLayouts().size() + 1);
-            MethodType mtype = MethodType.methodType(function.returnLayout().isPresent() ? carrier(function.returnLayout().get(), true) : void.class);
-            for (MemoryLayout layout : function.argumentLayouts()) {
-                mtype = mtype.appendParameterTypes(carrier(layout, false));
-            }
-            mtype = mtype.appendParameterTypes(Object[].class);
-            boolean needsAllocator = function.returnLayout().isPresent() &&
-                                function.returnLayout().get() instanceof GroupLayout;
-            if (needsAllocator) {
-                mtype = mtype.insertParameterTypes(0, SegmentAllocator.class);
-            } else {
-                handle = MethodHandles.insertArguments(handle, 0, THROWING_ALLOCATOR);
-            }
-            return handle.asType(mtype);
-        }
-
-        static Class<?> carrier(MemoryLayout layout, boolean ret) {
-            if (layout instanceof ValueLayout valueLayout) {
-                return valueLayout.carrier();
-            } else if (layout instanceof GroupLayout) {
-                return MemorySegment.class;
-            } else {
-                throw new AssertionError("Cannot get here!");
-            }
-        }
-
-        private Object invoke(SegmentAllocator allocator, Object[] args) throws Throwable {
-            // one trailing Object[]
-            int nNamedArgs = function.argumentLayouts().size();
-            assert(args.length == nNamedArgs + 1);
-            // The last argument is the array of vararg collector
-            Object[] unnamedArgs = (Object[]) args[args.length - 1];
-
-            int argsCount = nNamedArgs + unnamedArgs.length;
-            Class<?>[] argTypes = new Class<?>[argsCount];
-            MemoryLayout[] argLayouts = new MemoryLayout[nNamedArgs + unnamedArgs.length];
-
-            int pos = 0;
-            for (pos = 0; pos < nNamedArgs; pos++) {
-                argLayouts[pos] = function.argumentLayouts().get(pos);
-            }
-
-            assert pos == nNamedArgs;
-            for (Object o: unnamedArgs) {
-                argLayouts[pos] = variadicLayout(normalize(o.getClass()));
-                pos++;
-            }
-            assert pos == argsCount;
-
-            FunctionDescriptor f = (function.returnLayout().isEmpty()) ?
-                    FunctionDescriptor.ofVoid(argLayouts) :
-                    FunctionDescriptor.of(function.returnLayout().get(), argLayouts);
-            MethodHandle mh = LINKER.downcallHandle(symbol, f);
-            boolean needsAllocator = function.returnLayout().isPresent() &&
-                                            function.returnLayout().get() instanceof GroupLayout;
-            if (needsAllocator) {
-                mh = mh.bindTo(allocator);
-            }
-            // flatten argument list so that it can be passed to an asSpreader MH
-            Object[] allArgs = new Object[nNamedArgs + unnamedArgs.length];
-            System.arraycopy(args, 0, allArgs, 0, nNamedArgs);
-            System.arraycopy(unnamedArgs, 0, allArgs, nNamedArgs, unnamedArgs.length);
-
-            return mh.asSpreader(Object[].class, argsCount).invoke(allArgs);
-        }
-
-        private static Class<?> unboxIfNeeded(Class<?> clazz) {
-            if (clazz == Boolean.class) {
-                return boolean.class;
-            } else if (clazz == Void.class) {
-                return void.class;
-            } else if (clazz == Byte.class) {
-                return byte.class;
-            } else if (clazz == Character.class) {
-                return char.class;
-            } else if (clazz == Short.class) {
-                return short.class;
-            } else if (clazz == Integer.class) {
-                return int.class;
-            } else if (clazz == Long.class) {
-                return long.class;
-            } else if (clazz == Float.class) {
-                return float.class;
-            } else if (clazz == Double.class) {
-                return double.class;
-            } else {
-                return clazz;
-            }
-        }
-
-        private Class<?> promote(Class<?> c) {
-            if (c == byte.class || c == char.class || c == short.class || c == int.class) {
-                return long.class;
-            } else if (c == float.class) {
-                return double.class;
-            } else {
-                return c;
-            }
-        }
-
-        private Class<?> normalize(Class<?> c) {
-            c = unboxIfNeeded(c);
-            if (c.isPrimitive()) {
-                return promote(c);
-            }
-            if (c == MemorySegment.class) {
-                return MemorySegment.class;
-            }
-            throw new IllegalArgumentException("Invalid type for ABI: " + c.getTypeName());
-        }
-
-        private MemoryLayout variadicLayout(Class<?> c) {
-            if (c == long.class) {
-                return JAVA_LONG;
-            } else if (c == double.class) {
-                return JAVA_DOUBLE;
-            } else if (c == MemorySegment.class) {
-                return ADDRESS;
-            } else {
-                throw new IllegalArgumentException("Unhandled variadic argument class: " + c);
-            }
-        }
-    }
-}
diff --git a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/stat/constants$0.java b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/stat/constants$0.java
deleted file mode 100644
index dccfb7d8..00000000
--- a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/stat/constants$0.java
+++ /dev/null
@@ -1,16 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.linux.amd64.extr.stat;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$0 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$0() {}
-}
-
-
diff --git a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/stat/stat_h.java b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/stat/stat_h.java
index a4bd2686..0ca73473 100644
--- a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/stat/stat_h.java
+++ b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/stat/stat_h.java
@@ -2,37 +2,89 @@
 
 package org.cryptomator.jfuse.linux.amd64.extr.stat;
 
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
+import java.lang.invoke.*;
 import java.lang.foreign.*;
+import java.nio.ByteOrder;
+import java.util.*;
+import java.util.function.*;
+import java.util.stream.*;
+
 import static java.lang.foreign.ValueLayout.*;
-public class stat_h  {
-
-    public static final OfByte C_CHAR = JAVA_BYTE;
-    public static final OfShort C_SHORT = JAVA_SHORT;
-    public static final OfInt C_INT = JAVA_INT;
-    public static final OfLong C_LONG = JAVA_LONG;
-    public static final OfLong C_LONG_LONG = JAVA_LONG;
-    public static final OfFloat C_FLOAT = JAVA_FLOAT;
-    public static final OfDouble C_DOUBLE = JAVA_DOUBLE;
-    public static final AddressLayout C_POINTER = RuntimeHelper.POINTER;
+import static java.lang.foreign.MemoryLayout.PathElement.*;
+
+public class stat_h {
+
+    stat_h() {
+        // Should not be called directly
+    }
+
+    static final Arena LIBRARY_ARENA = Arena.ofAuto();
+    static final boolean TRACE_DOWNCALLS = Boolean.getBoolean("jextract.trace.downcalls");
+
+    static void traceDowncall(String name, Object... args) {
+         String traceArgs = Arrays.stream(args)
+                       .map(Object::toString)
+                       .collect(Collectors.joining(", "));
+         System.out.printf("%s(%s)\n", name, traceArgs);
+    }
+
+    static MemorySegment findOrThrow(String symbol) {
+        return SYMBOL_LOOKUP.find(symbol)
+            .orElseThrow(() -> new UnsatisfiedLinkError("unresolved symbol: " + symbol));
+    }
+
+    static MethodHandle upcallHandle(Class<?> fi, String name, FunctionDescriptor fdesc) {
+        try {
+            return MethodHandles.lookup().findVirtual(fi, name, fdesc.toMethodType());
+        } catch (ReflectiveOperationException ex) {
+            throw new AssertionError(ex);
+        }
+    }
+
+    static MemoryLayout align(MemoryLayout layout, long align) {
+        return switch (layout) {
+            case PaddingLayout p -> p;
+            case ValueLayout v -> v.withByteAlignment(align);
+            case GroupLayout g -> {
+                MemoryLayout[] alignedMembers = g.memberLayouts().stream()
+                        .map(m -> align(m, align)).toArray(MemoryLayout[]::new);
+                yield g instanceof StructLayout ?
+                        MemoryLayout.structLayout(alignedMembers) : MemoryLayout.unionLayout(alignedMembers);
+            }
+            case SequenceLayout s -> MemoryLayout.sequenceLayout(s.elementCount(), align(s.elementLayout(), align));
+        };
+    }
+
+    static final SymbolLookup SYMBOL_LOOKUP = SymbolLookup.loaderLookup()
+            .or(Linker.nativeLinker().defaultLookup());
+
+    public static final ValueLayout.OfBoolean C_BOOL = ValueLayout.JAVA_BOOLEAN;
+    public static final ValueLayout.OfByte C_CHAR = ValueLayout.JAVA_BYTE;
+    public static final ValueLayout.OfShort C_SHORT = ValueLayout.JAVA_SHORT;
+    public static final ValueLayout.OfInt C_INT = ValueLayout.JAVA_INT;
+    public static final ValueLayout.OfLong C_LONG_LONG = ValueLayout.JAVA_LONG;
+    public static final ValueLayout.OfFloat C_FLOAT = ValueLayout.JAVA_FLOAT;
+    public static final ValueLayout.OfDouble C_DOUBLE = ValueLayout.JAVA_DOUBLE;
+    public static final AddressLayout C_POINTER = ValueLayout.ADDRESS
+            .withTargetLayout(MemoryLayout.sequenceLayout(java.lang.Long.MAX_VALUE, JAVA_BYTE));
+    public static final ValueLayout.OfLong C_LONG = ValueLayout.JAVA_LONG;
+    private static final long UTIME_NOW = 1073741823L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define UTIME_NOW 1073741823
      * }
      */
     public static long UTIME_NOW() {
-        return 1073741823L;
+        return UTIME_NOW;
     }
+    private static final long UTIME_OMIT = 1073741822L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define UTIME_OMIT 1073741822
      * }
      */
     public static long UTIME_OMIT() {
-        return 1073741822L;
+        return UTIME_OMIT;
     }
 }
 
-
diff --git a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/stdio/RuntimeHelper.java b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/stdio/RuntimeHelper.java
deleted file mode 100644
index 9db43b24..00000000
--- a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/stdio/RuntimeHelper.java
+++ /dev/null
@@ -1,245 +0,0 @@
-package org.cryptomator.jfuse.linux.amd64.extr.stdio;
-// Generated by jextract
-
-import java.lang.foreign.Linker;
-import java.lang.foreign.FunctionDescriptor;
-import java.lang.foreign.GroupLayout;
-import java.lang.foreign.SymbolLookup;
-import java.lang.foreign.MemoryLayout;
-import java.lang.foreign.MemorySegment;
-import java.lang.foreign.Arena;
-import java.lang.foreign.SegmentAllocator;
-import java.lang.foreign.ValueLayout;
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.MethodHandles;
-import java.lang.invoke.MethodType;
-import java.io.File;
-import java.nio.file.Path;
-import java.nio.charset.StandardCharsets;
-import java.util.Arrays;
-import java.util.Optional;
-import java.util.stream.Stream;
-
-import java.lang.foreign.AddressLayout;
-import java.lang.foreign.MemoryLayout;
-
-import static java.lang.foreign.Linker.*;
-import static java.lang.foreign.ValueLayout.*;
-
-final class RuntimeHelper {
-
-    private static final Linker LINKER = Linker.nativeLinker();
-    private static final ClassLoader LOADER = RuntimeHelper.class.getClassLoader();
-    private static final MethodHandles.Lookup MH_LOOKUP = MethodHandles.lookup();
-    private static final SymbolLookup SYMBOL_LOOKUP;
-    private static final SegmentAllocator THROWING_ALLOCATOR = (x, y) -> { throw new AssertionError("should not reach here"); };
-    static final AddressLayout POINTER = ValueLayout.ADDRESS.withTargetLayout(MemoryLayout.sequenceLayout(JAVA_BYTE));
-
-    final static SegmentAllocator CONSTANT_ALLOCATOR =
-            (size, align) -> Arena.ofAuto().allocate(size, align);
-
-    static {
-        
-        SymbolLookup loaderLookup = SymbolLookup.loaderLookup();
-        SYMBOL_LOOKUP = name -> loaderLookup.find(name).or(() -> LINKER.defaultLookup().find(name));
-    }
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private RuntimeHelper() {}
-
-    static <T> T requireNonNull(T obj, String symbolName) {
-        if (obj == null) {
-            throw new UnsatisfiedLinkError("unresolved symbol: " + symbolName);
-        }
-        return obj;
-    }
-
-    static MemorySegment lookupGlobalVariable(String name, MemoryLayout layout) {
-        return SYMBOL_LOOKUP.find(name)
-                .map(s -> s.reinterpret(layout.byteSize()))
-                .orElse(null);
-    }
-
-    static MethodHandle downcallHandle(String name, FunctionDescriptor fdesc) {
-        return SYMBOL_LOOKUP.find(name).
-                map(addr -> LINKER.downcallHandle(addr, fdesc)).
-                orElse(null);
-    }
-
-    static MethodHandle downcallHandle(FunctionDescriptor fdesc) {
-        return LINKER.downcallHandle(fdesc);
-    }
-
-    static MethodHandle downcallHandleVariadic(String name, FunctionDescriptor fdesc) {
-        return SYMBOL_LOOKUP.find(name).
-                map(addr -> VarargsInvoker.make(addr, fdesc)).
-                orElse(null);
-    }
-
-    static MethodHandle upcallHandle(Class<?> fi, String name, FunctionDescriptor fdesc) {
-        try {
-            return MH_LOOKUP.findVirtual(fi, name, fdesc.toMethodType());
-        } catch (Throwable ex) {
-            throw new AssertionError(ex);
-        }
-    }
-
-    static <Z> MemorySegment upcallStub(MethodHandle fiHandle, Z z, FunctionDescriptor fdesc, Arena scope) {
-        try {
-            fiHandle = fiHandle.bindTo(z);
-            return LINKER.upcallStub(fiHandle, fdesc, scope);
-        } catch (Throwable ex) {
-            throw new AssertionError(ex);
-        }
-    }
-
-    static MemorySegment asArray(MemorySegment addr, MemoryLayout layout, int numElements, Arena arena) {
-         return addr.reinterpret(numElements * layout.byteSize(), arena, null);
-    }
-
-    // Internals only below this point
-
-    private static final class VarargsInvoker {
-        private static final MethodHandle INVOKE_MH;
-        private final MemorySegment symbol;
-        private final FunctionDescriptor function;
-
-        private VarargsInvoker(MemorySegment symbol, FunctionDescriptor function) {
-            this.symbol = symbol;
-            this.function = function;
-        }
-
-        static {
-            try {
-                INVOKE_MH = MethodHandles.lookup().findVirtual(VarargsInvoker.class, "invoke", MethodType.methodType(Object.class, SegmentAllocator.class, Object[].class));
-            } catch (ReflectiveOperationException e) {
-                throw new RuntimeException(e);
-            }
-        }
-
-        static MethodHandle make(MemorySegment symbol, FunctionDescriptor function) {
-            VarargsInvoker invoker = new VarargsInvoker(symbol, function);
-            MethodHandle handle = INVOKE_MH.bindTo(invoker).asCollector(Object[].class, function.argumentLayouts().size() + 1);
-            MethodType mtype = MethodType.methodType(function.returnLayout().isPresent() ? carrier(function.returnLayout().get(), true) : void.class);
-            for (MemoryLayout layout : function.argumentLayouts()) {
-                mtype = mtype.appendParameterTypes(carrier(layout, false));
-            }
-            mtype = mtype.appendParameterTypes(Object[].class);
-            boolean needsAllocator = function.returnLayout().isPresent() &&
-                                function.returnLayout().get() instanceof GroupLayout;
-            if (needsAllocator) {
-                mtype = mtype.insertParameterTypes(0, SegmentAllocator.class);
-            } else {
-                handle = MethodHandles.insertArguments(handle, 0, THROWING_ALLOCATOR);
-            }
-            return handle.asType(mtype);
-        }
-
-        static Class<?> carrier(MemoryLayout layout, boolean ret) {
-            if (layout instanceof ValueLayout valueLayout) {
-                return valueLayout.carrier();
-            } else if (layout instanceof GroupLayout) {
-                return MemorySegment.class;
-            } else {
-                throw new AssertionError("Cannot get here!");
-            }
-        }
-
-        private Object invoke(SegmentAllocator allocator, Object[] args) throws Throwable {
-            // one trailing Object[]
-            int nNamedArgs = function.argumentLayouts().size();
-            assert(args.length == nNamedArgs + 1);
-            // The last argument is the array of vararg collector
-            Object[] unnamedArgs = (Object[]) args[args.length - 1];
-
-            int argsCount = nNamedArgs + unnamedArgs.length;
-            Class<?>[] argTypes = new Class<?>[argsCount];
-            MemoryLayout[] argLayouts = new MemoryLayout[nNamedArgs + unnamedArgs.length];
-
-            int pos = 0;
-            for (pos = 0; pos < nNamedArgs; pos++) {
-                argLayouts[pos] = function.argumentLayouts().get(pos);
-            }
-
-            assert pos == nNamedArgs;
-            for (Object o: unnamedArgs) {
-                argLayouts[pos] = variadicLayout(normalize(o.getClass()));
-                pos++;
-            }
-            assert pos == argsCount;
-
-            FunctionDescriptor f = (function.returnLayout().isEmpty()) ?
-                    FunctionDescriptor.ofVoid(argLayouts) :
-                    FunctionDescriptor.of(function.returnLayout().get(), argLayouts);
-            MethodHandle mh = LINKER.downcallHandle(symbol, f);
-            boolean needsAllocator = function.returnLayout().isPresent() &&
-                                            function.returnLayout().get() instanceof GroupLayout;
-            if (needsAllocator) {
-                mh = mh.bindTo(allocator);
-            }
-            // flatten argument list so that it can be passed to an asSpreader MH
-            Object[] allArgs = new Object[nNamedArgs + unnamedArgs.length];
-            System.arraycopy(args, 0, allArgs, 0, nNamedArgs);
-            System.arraycopy(unnamedArgs, 0, allArgs, nNamedArgs, unnamedArgs.length);
-
-            return mh.asSpreader(Object[].class, argsCount).invoke(allArgs);
-        }
-
-        private static Class<?> unboxIfNeeded(Class<?> clazz) {
-            if (clazz == Boolean.class) {
-                return boolean.class;
-            } else if (clazz == Void.class) {
-                return void.class;
-            } else if (clazz == Byte.class) {
-                return byte.class;
-            } else if (clazz == Character.class) {
-                return char.class;
-            } else if (clazz == Short.class) {
-                return short.class;
-            } else if (clazz == Integer.class) {
-                return int.class;
-            } else if (clazz == Long.class) {
-                return long.class;
-            } else if (clazz == Float.class) {
-                return float.class;
-            } else if (clazz == Double.class) {
-                return double.class;
-            } else {
-                return clazz;
-            }
-        }
-
-        private Class<?> promote(Class<?> c) {
-            if (c == byte.class || c == char.class || c == short.class || c == int.class) {
-                return long.class;
-            } else if (c == float.class) {
-                return double.class;
-            } else {
-                return c;
-            }
-        }
-
-        private Class<?> normalize(Class<?> c) {
-            c = unboxIfNeeded(c);
-            if (c.isPrimitive()) {
-                return promote(c);
-            }
-            if (c == MemorySegment.class) {
-                return MemorySegment.class;
-            }
-            throw new IllegalArgumentException("Invalid type for ABI: " + c.getTypeName());
-        }
-
-        private MemoryLayout variadicLayout(Class<?> c) {
-            if (c == long.class) {
-                return JAVA_LONG;
-            } else if (c == double.class) {
-                return JAVA_DOUBLE;
-            } else if (c == MemorySegment.class) {
-                return ADDRESS;
-            } else {
-                throw new IllegalArgumentException("Unhandled variadic argument class: " + c);
-            }
-        }
-    }
-}
diff --git a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/stdio/constants$0.java b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/stdio/constants$0.java
deleted file mode 100644
index 5e033479..00000000
--- a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/stdio/constants$0.java
+++ /dev/null
@@ -1,16 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.linux.amd64.extr.stdio;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$0 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$0() {}
-}
-
-
diff --git a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/stdio/stdio_h.java b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/stdio/stdio_h.java
index 77a3b805..b48333e3 100644
--- a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/stdio/stdio_h.java
+++ b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/stdio/stdio_h.java
@@ -2,45 +2,98 @@
 
 package org.cryptomator.jfuse.linux.amd64.extr.stdio;
 
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
+import java.lang.invoke.*;
 import java.lang.foreign.*;
+import java.nio.ByteOrder;
+import java.util.*;
+import java.util.function.*;
+import java.util.stream.*;
+
 import static java.lang.foreign.ValueLayout.*;
-public class stdio_h  {
-
-    public static final OfByte C_CHAR = JAVA_BYTE;
-    public static final OfShort C_SHORT = JAVA_SHORT;
-    public static final OfInt C_INT = JAVA_INT;
-    public static final OfLong C_LONG = JAVA_LONG;
-    public static final OfLong C_LONG_LONG = JAVA_LONG;
-    public static final OfFloat C_FLOAT = JAVA_FLOAT;
-    public static final OfDouble C_DOUBLE = JAVA_DOUBLE;
-    public static final AddressLayout C_POINTER = RuntimeHelper.POINTER;
+import static java.lang.foreign.MemoryLayout.PathElement.*;
+
+public class stdio_h {
+
+    stdio_h() {
+        // Should not be called directly
+    }
+
+    static final Arena LIBRARY_ARENA = Arena.ofAuto();
+    static final boolean TRACE_DOWNCALLS = Boolean.getBoolean("jextract.trace.downcalls");
+
+    static void traceDowncall(String name, Object... args) {
+         String traceArgs = Arrays.stream(args)
+                       .map(Object::toString)
+                       .collect(Collectors.joining(", "));
+         System.out.printf("%s(%s)\n", name, traceArgs);
+    }
+
+    static MemorySegment findOrThrow(String symbol) {
+        return SYMBOL_LOOKUP.find(symbol)
+            .orElseThrow(() -> new UnsatisfiedLinkError("unresolved symbol: " + symbol));
+    }
+
+    static MethodHandle upcallHandle(Class<?> fi, String name, FunctionDescriptor fdesc) {
+        try {
+            return MethodHandles.lookup().findVirtual(fi, name, fdesc.toMethodType());
+        } catch (ReflectiveOperationException ex) {
+            throw new AssertionError(ex);
+        }
+    }
+
+    static MemoryLayout align(MemoryLayout layout, long align) {
+        return switch (layout) {
+            case PaddingLayout p -> p;
+            case ValueLayout v -> v.withByteAlignment(align);
+            case GroupLayout g -> {
+                MemoryLayout[] alignedMembers = g.memberLayouts().stream()
+                        .map(m -> align(m, align)).toArray(MemoryLayout[]::new);
+                yield g instanceof StructLayout ?
+                        MemoryLayout.structLayout(alignedMembers) : MemoryLayout.unionLayout(alignedMembers);
+            }
+            case SequenceLayout s -> MemoryLayout.sequenceLayout(s.elementCount(), align(s.elementLayout(), align));
+        };
+    }
+
+    static final SymbolLookup SYMBOL_LOOKUP = SymbolLookup.loaderLookup()
+            .or(Linker.nativeLinker().defaultLookup());
+
+    public static final ValueLayout.OfBoolean C_BOOL = ValueLayout.JAVA_BOOLEAN;
+    public static final ValueLayout.OfByte C_CHAR = ValueLayout.JAVA_BYTE;
+    public static final ValueLayout.OfShort C_SHORT = ValueLayout.JAVA_SHORT;
+    public static final ValueLayout.OfInt C_INT = ValueLayout.JAVA_INT;
+    public static final ValueLayout.OfLong C_LONG_LONG = ValueLayout.JAVA_LONG;
+    public static final ValueLayout.OfFloat C_FLOAT = ValueLayout.JAVA_FLOAT;
+    public static final ValueLayout.OfDouble C_DOUBLE = ValueLayout.JAVA_DOUBLE;
+    public static final AddressLayout C_POINTER = ValueLayout.ADDRESS
+            .withTargetLayout(MemoryLayout.sequenceLayout(java.lang.Long.MAX_VALUE, JAVA_BYTE));
+    public static final ValueLayout.OfLong C_LONG = ValueLayout.JAVA_LONG;
+    private static final int RENAME_NOREPLACE = (int)1L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define RENAME_NOREPLACE 1
      * }
      */
     public static int RENAME_NOREPLACE() {
-        return (int)1L;
+        return RENAME_NOREPLACE;
     }
+    private static final int RENAME_EXCHANGE = (int)2L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define RENAME_EXCHANGE 2
      * }
      */
     public static int RENAME_EXCHANGE() {
-        return (int)2L;
+        return RENAME_EXCHANGE;
     }
+    private static final int RENAME_WHITEOUT = (int)4L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define RENAME_WHITEOUT 4
      * }
      */
     public static int RENAME_WHITEOUT() {
-        return (int)4L;
+        return RENAME_WHITEOUT;
     }
 }
 
-
diff --git a/jfuse-linux-amd64/src/test/java/org/cryptomator/jfuse/linux/amd64/FileInfoImplTest.java b/jfuse-linux-amd64/src/test/java/org/cryptomator/jfuse/linux/amd64/FileInfoImplTest.java
index d3a1ff3b..17f34731 100644
--- a/jfuse-linux-amd64/src/test/java/org/cryptomator/jfuse/linux/amd64/FileInfoImplTest.java
+++ b/jfuse-linux-amd64/src/test/java/org/cryptomator/jfuse/linux/amd64/FileInfoImplTest.java
@@ -22,7 +22,7 @@ public class FileInfoImplTest {
 	public void testGetOpenFlags(int flags, Set<OpenOption> expectedResult) {
 		try (var arena = Arena.ofConfined()) {
 			var fi = new FileInfoImpl(fuse_file_info.allocate(arena));
-			fuse_file_info.flags$set(fi.segment(), flags);
+			fuse_file_info.flags(fi.segment(), flags);
 
 			var result = fi.getOpenFlags();
 
diff --git a/jfuse-linux-amd64/src/test/java/org/cryptomator/jfuse/linux/amd64/FuseConfigImplTest.java b/jfuse-linux-amd64/src/test/java/org/cryptomator/jfuse/linux/amd64/FuseConfigImplTest.java
index a7de2cd4..9a8bc676 100644
--- a/jfuse-linux-amd64/src/test/java/org/cryptomator/jfuse/linux/amd64/FuseConfigImplTest.java
+++ b/jfuse-linux-amd64/src/test/java/org/cryptomator/jfuse/linux/amd64/FuseConfigImplTest.java
@@ -23,7 +23,7 @@ public class FuseConfigImplTest {
 	public void testGetters(SetInMemorySegment<Number> setter, GetInFuseConfig<Number> getter, Number value) {
 		try (var arena = Arena.ofConfined()) {
 			var segment = fuse_config.allocate(arena);
-			var fuseConfig = new FuseConfigImpl(segment, arena);
+			var fuseConfig = new FuseConfigImpl(segment);
 
 			setter.accept(segment, value);
 
@@ -33,28 +33,28 @@ public void testGetters(SetInMemorySegment<Number> setter, GetInFuseConfig<Numbe
 
 	public static Stream<Arguments> testGetters() {
 		return Stream.of(
-				Arguments.arguments((SetInMemorySegment<Integer>) fuse_config::set_gid$set, Named.of("setGid()", (GetInFuseConfig<Integer>) FuseConfig::setGid), 42),
-				Arguments.arguments((SetInMemorySegment<Integer>) fuse_config::gid$set, Named.of("gid()", (GetInFuseConfig<Integer>) FuseConfig::gid), 42),
-				Arguments.arguments((SetInMemorySegment<Integer>) fuse_config::set_uid$set, Named.of("setUid()", (GetInFuseConfig<Integer>) FuseConfig::setUid), 42),
-				Arguments.arguments((SetInMemorySegment<Integer>) fuse_config::uid$set, Named.of("uid()", (GetInFuseConfig<Integer>) FuseConfig::uid), 42),
-				Arguments.arguments((SetInMemorySegment<Integer>) fuse_config::set_mode$set, Named.of("setMode()", (GetInFuseConfig<Integer>) FuseConfig::setMode), 42),
-				Arguments.arguments((SetInMemorySegment<Integer>) fuse_config::umask$set, Named.of("umask()", (GetInFuseConfig<Integer>) FuseConfig::umask), 42),
-				Arguments.arguments((SetInMemorySegment<Double>) fuse_config::entry_timeout$set, Named.of("entryTimeout()", (GetInFuseConfig<Double>) FuseConfig::entryTimeout), 4.2),
-				Arguments.arguments((SetInMemorySegment<Double>) fuse_config::negative_timeout$set, Named.of("negativeTimeout()", (GetInFuseConfig<Double>) FuseConfig::negativeTimeout), 4.2),
-				Arguments.arguments((SetInMemorySegment<Double>) fuse_config::attr_timeout$set, Named.of("attrTimeout()", (GetInFuseConfig<Double>) FuseConfig::attrTimeout), 4.2),
-				Arguments.arguments((SetInMemorySegment<Integer>) fuse_config::intr$set, Named.of("intr()", (GetInFuseConfig<Integer>) FuseConfig::intr), 42),
-				Arguments.arguments((SetInMemorySegment<Integer>) fuse_config::intr_signal$set, Named.of("intrSignal()", (GetInFuseConfig<Integer>) FuseConfig::intrSignal), 42),
-				Arguments.arguments((SetInMemorySegment<Integer>) fuse_config::remember$set, Named.of("remember()", (GetInFuseConfig<Integer>) FuseConfig::remember), 42),
-				Arguments.arguments((SetInMemorySegment<Integer>) fuse_config::hard_remove$set, Named.of("hardRemove()", (GetInFuseConfig<Integer>) FuseConfig::hardRemove), 42),
-				Arguments.arguments((SetInMemorySegment<Integer>) fuse_config::use_ino$set, Named.of("useIno()", (GetInFuseConfig<Integer>) FuseConfig::useIno), 42),
-				Arguments.arguments((SetInMemorySegment<Integer>) fuse_config::readdir_ino$set, Named.of("readdirIno()", (GetInFuseConfig<Integer>) FuseConfig::readdirIno), 42),
-				Arguments.arguments((SetInMemorySegment<Integer>) fuse_config::direct_io$set, Named.of("directIo()", (GetInFuseConfig<Integer>) FuseConfig::directIo), 42),
-				Arguments.arguments((SetInMemorySegment<Integer>) fuse_config::kernel_cache$set, Named.of("kernelCache()", (GetInFuseConfig<Integer>) FuseConfig::kernelCache), 42),
-				Arguments.arguments((SetInMemorySegment<Integer>) fuse_config::auto_cache$set, Named.of("autoCache()", (GetInFuseConfig<Integer>) FuseConfig::autoCache), 42),
-				Arguments.arguments((SetInMemorySegment<Integer>) fuse_config::ac_attr_timeout_set$set, Named.of("acAtrrTimeoutSet()", (GetInFuseConfig<Integer>) FuseConfig::acAttrTimeoutSet), 42),
-				Arguments.arguments((SetInMemorySegment<Double>) fuse_config::ac_attr_timeout$set, Named.of("acAttrTimeout()", (GetInFuseConfig<Double>) FuseConfig::acAttrTimeout), 4.2),
-				Arguments.arguments((SetInMemorySegment<Integer>) fuse_config::nullpath_ok$set, Named.of("nullpathOk()", (GetInFuseConfig<Integer>) FuseConfig::nullpathOk), 42),
-				Arguments.arguments((SetInMemorySegment<Integer>) fuse_config::no_rofd_flush$set, Named.of("noRofdFlush()", (GetInFuseConfig<Integer>) FuseConfig::noRofdFlush), 42)
+				Arguments.arguments((SetInMemorySegment<Integer>) fuse_config::set_gid, Named.of("setGid()", (GetInFuseConfig<Integer>) FuseConfig::setGid), 42),
+				Arguments.arguments((SetInMemorySegment<Integer>) fuse_config::gid, Named.of("gid()", (GetInFuseConfig<Integer>) FuseConfig::gid), 42),
+				Arguments.arguments((SetInMemorySegment<Integer>) fuse_config::set_uid, Named.of("setUid()", (GetInFuseConfig<Integer>) FuseConfig::setUid), 42),
+				Arguments.arguments((SetInMemorySegment<Integer>) fuse_config::uid, Named.of("uid()", (GetInFuseConfig<Integer>) FuseConfig::uid), 42),
+				Arguments.arguments((SetInMemorySegment<Integer>) fuse_config::set_mode, Named.of("setMode()", (GetInFuseConfig<Integer>) FuseConfig::setMode), 42),
+				Arguments.arguments((SetInMemorySegment<Integer>) fuse_config::umask, Named.of("umask()", (GetInFuseConfig<Integer>) FuseConfig::umask), 42),
+				Arguments.arguments((SetInMemorySegment<Double>) fuse_config::entry_timeout, Named.of("entryTimeout()", (GetInFuseConfig<Double>) FuseConfig::entryTimeout), 4.2),
+				Arguments.arguments((SetInMemorySegment<Double>) fuse_config::negative_timeout, Named.of("negativeTimeout()", (GetInFuseConfig<Double>) FuseConfig::negativeTimeout), 4.2),
+				Arguments.arguments((SetInMemorySegment<Double>) fuse_config::attr_timeout, Named.of("attrTimeout()", (GetInFuseConfig<Double>) FuseConfig::attrTimeout), 4.2),
+				Arguments.arguments((SetInMemorySegment<Integer>) fuse_config::intr, Named.of("intr()", (GetInFuseConfig<Integer>) FuseConfig::intr), 42),
+				Arguments.arguments((SetInMemorySegment<Integer>) fuse_config::intr_signal, Named.of("intrSignal()", (GetInFuseConfig<Integer>) FuseConfig::intrSignal), 42),
+				Arguments.arguments((SetInMemorySegment<Integer>) fuse_config::remember, Named.of("remember()", (GetInFuseConfig<Integer>) FuseConfig::remember), 42),
+				Arguments.arguments((SetInMemorySegment<Integer>) fuse_config::hard_remove, Named.of("hardRemove()", (GetInFuseConfig<Integer>) FuseConfig::hardRemove), 42),
+				Arguments.arguments((SetInMemorySegment<Integer>) fuse_config::use_ino, Named.of("useIno()", (GetInFuseConfig<Integer>) FuseConfig::useIno), 42),
+				Arguments.arguments((SetInMemorySegment<Integer>) fuse_config::readdir_ino, Named.of("readdirIno()", (GetInFuseConfig<Integer>) FuseConfig::readdirIno), 42),
+				Arguments.arguments((SetInMemorySegment<Integer>) fuse_config::direct_io, Named.of("directIo()", (GetInFuseConfig<Integer>) FuseConfig::directIo), 42),
+				Arguments.arguments((SetInMemorySegment<Integer>) fuse_config::kernel_cache, Named.of("kernelCache()", (GetInFuseConfig<Integer>) FuseConfig::kernelCache), 42),
+				Arguments.arguments((SetInMemorySegment<Integer>) fuse_config::auto_cache, Named.of("autoCache()", (GetInFuseConfig<Integer>) FuseConfig::autoCache), 42),
+				Arguments.arguments((SetInMemorySegment<Integer>) fuse_config::ac_attr_timeout_set, Named.of("acAtrrTimeoutSet()", (GetInFuseConfig<Integer>) FuseConfig::acAttrTimeoutSet), 42),
+				Arguments.arguments((SetInMemorySegment<Double>) fuse_config::ac_attr_timeout, Named.of("acAttrTimeout()", (GetInFuseConfig<Double>) FuseConfig::acAttrTimeout), 4.2),
+				Arguments.arguments((SetInMemorySegment<Integer>) fuse_config::nullpath_ok, Named.of("nullpathOk()", (GetInFuseConfig<Integer>) FuseConfig::nullpathOk), 42),
+				Arguments.arguments((SetInMemorySegment<Integer>) fuse_config::no_rofd_flush, Named.of("noRofdFlush()", (GetInFuseConfig<Integer>) FuseConfig::noRofdFlush), 42)
 		);
 	}
 
diff --git a/jfuse-linux-amd64/src/test/java/org/cryptomator/jfuse/linux/amd64/FuseConnInfoImplTest.java b/jfuse-linux-amd64/src/test/java/org/cryptomator/jfuse/linux/amd64/FuseConnInfoImplTest.java
index 214089af..6165d960 100644
--- a/jfuse-linux-amd64/src/test/java/org/cryptomator/jfuse/linux/amd64/FuseConnInfoImplTest.java
+++ b/jfuse-linux-amd64/src/test/java/org/cryptomator/jfuse/linux/amd64/FuseConnInfoImplTest.java
@@ -23,7 +23,7 @@ public class FuseConnInfoImplTest {
 	public void testGetters(SetInMemorySegment setter, GetInConnInfo getter) {
 		try (var arena = Arena.ofConfined()) {
 			var segment = fuse_conn_info.allocate(arena);
-			var connInfo = new FuseConnInfoImpl(segment, arena);
+			var connInfo = new FuseConnInfoImpl(segment);
 
 			setter.accept(segment, 42);
 
@@ -33,16 +33,16 @@ public void testGetters(SetInMemorySegment setter, GetInConnInfo getter) {
 
 	public static Stream<Arguments> testGetters() {
 		return Stream.of(
-				Arguments.arguments((SetInMemorySegment) fuse_conn_info::proto_major$set, Named.of("protoMajor()", (GetInConnInfo) FuseConnInfo::protoMajor)),
-				Arguments.arguments((SetInMemorySegment) fuse_conn_info::proto_minor$set, Named.of("protoMinor()", (GetInConnInfo) FuseConnInfo::protoMinor)),
-				Arguments.arguments((SetInMemorySegment) fuse_conn_info::capable$set, Named.of("capable()", (GetInConnInfo) FuseConnInfo::capable)),
-				Arguments.arguments((SetInMemorySegment) fuse_conn_info::max_write$set, Named.of("maxWrite()", (GetInConnInfo) FuseConnInfo::maxWrite)),
-				Arguments.arguments((SetInMemorySegment) fuse_conn_info::max_read$set, Named.of("maxRead()", (GetInConnInfo) FuseConnInfo::maxRead)),
-				Arguments.arguments((SetInMemorySegment) fuse_conn_info::max_readahead$set, Named.of("maxReadahead()", (GetInConnInfo) FuseConnInfo::maxReadahead)),
-				Arguments.arguments((SetInMemorySegment) fuse_conn_info::max_background$set, Named.of("maxBackground()", (GetInConnInfo) FuseConnInfo::maxBackground)),
-				Arguments.arguments((SetInMemorySegment) fuse_conn_info::congestion_threshold$set, Named.of("congestionThreshold()", (GetInConnInfo) FuseConnInfo::congestionThreshold)),
-				Arguments.arguments((SetInMemorySegment) fuse_conn_info::time_gran$set, Named.of("timeGran()", (GetInConnInfo) FuseConnInfo::timeGran)),
-				Arguments.arguments((SetInMemorySegment) fuse_conn_info::want$set, Named.of("want()", (GetInConnInfo) FuseConnInfo::want))
+				Arguments.arguments((SetInMemorySegment) fuse_conn_info::proto_major, Named.of("protoMajor()", (GetInConnInfo) FuseConnInfo::protoMajor)),
+				Arguments.arguments((SetInMemorySegment) fuse_conn_info::proto_minor, Named.of("protoMinor()", (GetInConnInfo) FuseConnInfo::protoMinor)),
+				Arguments.arguments((SetInMemorySegment) fuse_conn_info::capable, Named.of("capable()", (GetInConnInfo) FuseConnInfo::capable)),
+				Arguments.arguments((SetInMemorySegment) fuse_conn_info::max_write, Named.of("maxWrite()", (GetInConnInfo) FuseConnInfo::maxWrite)),
+				Arguments.arguments((SetInMemorySegment) fuse_conn_info::max_read, Named.of("maxRead()", (GetInConnInfo) FuseConnInfo::maxRead)),
+				Arguments.arguments((SetInMemorySegment) fuse_conn_info::max_readahead, Named.of("maxReadahead()", (GetInConnInfo) FuseConnInfo::maxReadahead)),
+				Arguments.arguments((SetInMemorySegment) fuse_conn_info::max_background, Named.of("maxBackground()", (GetInConnInfo) FuseConnInfo::maxBackground)),
+				Arguments.arguments((SetInMemorySegment) fuse_conn_info::congestion_threshold, Named.of("congestionThreshold()", (GetInConnInfo) FuseConnInfo::congestionThreshold)),
+				Arguments.arguments((SetInMemorySegment) fuse_conn_info::time_gran, Named.of("timeGran()", (GetInConnInfo) FuseConnInfo::timeGran)),
+				Arguments.arguments((SetInMemorySegment) fuse_conn_info::want, Named.of("want()", (GetInConnInfo) FuseConnInfo::want))
 		);
 	}
 
@@ -56,7 +56,7 @@ private interface GetInConnInfo extends Function<FuseConnInfo, Integer> {}
 	public void testSetters(SetInConnInfo setter, GetInMemorySegment getter) {
 		try (var arena = Arena.ofConfined()) {
 			var segment = fuse_conn_info.allocate(arena);
-			var connInfo = new FuseConnInfoImpl(segment, arena);
+			var connInfo = new FuseConnInfoImpl(segment);
 
 			setter.accept(connInfo, 42);
 
@@ -66,13 +66,13 @@ public void testSetters(SetInConnInfo setter, GetInMemorySegment getter) {
 
 	public static Stream<Arguments> testSetters() {
 		return Stream.of(
-				Arguments.arguments(Named.of("setWant()", (SetInConnInfo) FuseConnInfo::setWant), (GetInMemorySegment) fuse_conn_info::want$get),
-				Arguments.arguments(Named.of("setMaxWrite()", (SetInConnInfo) FuseConnInfo::setMaxWrite), (GetInMemorySegment) fuse_conn_info::max_write$get),
-				Arguments.arguments(Named.of("setMaxRead()", (SetInConnInfo) FuseConnInfo::setMaxRead), (GetInMemorySegment) fuse_conn_info::max_read$get),
-				Arguments.arguments(Named.of("setMaxReadahead()", (SetInConnInfo) FuseConnInfo::setMaxReadahead), (GetInMemorySegment) fuse_conn_info::max_readahead$get),
-				Arguments.arguments(Named.of("setMaxBackground()", (SetInConnInfo) FuseConnInfo::setMaxBackground), (GetInMemorySegment) fuse_conn_info::max_background$get),
-				Arguments.arguments(Named.of("setCongestionThreshold()", (SetInConnInfo) FuseConnInfo::setCongestionThreshold), (GetInMemorySegment) fuse_conn_info::congestion_threshold$get),
-				Arguments.arguments(Named.of("setTimeGran()", (SetInConnInfo) FuseConnInfo::setTimeGran), (GetInMemorySegment) fuse_conn_info::time_gran$get)
+				Arguments.arguments(Named.of("setWant()", (SetInConnInfo) FuseConnInfo::setWant), (GetInMemorySegment) fuse_conn_info::want),
+				Arguments.arguments(Named.of("setMaxWrite()", (SetInConnInfo) FuseConnInfo::setMaxWrite), (GetInMemorySegment) fuse_conn_info::max_write),
+				Arguments.arguments(Named.of("setMaxRead()", (SetInConnInfo) FuseConnInfo::setMaxRead), (GetInMemorySegment) fuse_conn_info::max_read),
+				Arguments.arguments(Named.of("setMaxReadahead()", (SetInConnInfo) FuseConnInfo::setMaxReadahead), (GetInMemorySegment) fuse_conn_info::max_readahead),
+				Arguments.arguments(Named.of("setMaxBackground()", (SetInConnInfo) FuseConnInfo::setMaxBackground), (GetInMemorySegment) fuse_conn_info::max_background),
+				Arguments.arguments(Named.of("setCongestionThreshold()", (SetInConnInfo) FuseConnInfo::setCongestionThreshold), (GetInMemorySegment) fuse_conn_info::congestion_threshold),
+				Arguments.arguments(Named.of("setTimeGran()", (SetInConnInfo) FuseConnInfo::setTimeGran), (GetInMemorySegment) fuse_conn_info::time_gran)
 		);
 	}
 
diff --git a/jfuse-linux-amd64/src/test/java/org/cryptomator/jfuse/linux/amd64/FuseImplTest.java b/jfuse-linux-amd64/src/test/java/org/cryptomator/jfuse/linux/amd64/FuseImplTest.java
index 124e962c..b00ea182 100644
--- a/jfuse-linux-amd64/src/test/java/org/cryptomator/jfuse/linux/amd64/FuseImplTest.java
+++ b/jfuse-linux-amd64/src/test/java/org/cryptomator/jfuse/linux/amd64/FuseImplTest.java
@@ -86,7 +86,7 @@ public void testParseArgsHelp(String arg) {
 			 var fuseH = Mockito.mockStatic(fuse_h.class)) {
 			fuseFunctionsClass.when(() -> FuseFunctions.fuse_parse_cmdline(Mockito.any(), Mockito.any())).then(invocation -> {
 				MemorySegment opts = invocation.getArgument(1);
-				fuse_cmdline_opts.show_help$set(opts, 1);
+				fuse_cmdline_opts.show_help(opts, 1);
 				return 0;
 			});
 			fuseH.when(() -> fuse_h.fuse_lib_help(Mockito.any())).thenAnswer(Answers.RETURNS_DEFAULTS);
@@ -103,9 +103,9 @@ public void testParseArgs() {
 			 var arena = Arena.ofConfined()) {
 			fuseFunctionsClass.when(() -> FuseFunctions.fuse_parse_cmdline(Mockito.any(), Mockito.any())).then(invocation -> {
 				MemorySegment opts = invocation.getArgument(1);
-				fuse_cmdline_opts.singlethread$set(opts, 0);
-				fuse_cmdline_opts.debug$set(opts, 1);
-				fuse_cmdline_opts.mountpoint$set(opts, arena.allocateUtf8String("/mount/point"));
+				fuse_cmdline_opts.singlethread(opts, 0);
+				fuse_cmdline_opts.debug(opts, 1);
+				fuse_cmdline_opts.mountpoint(opts, arena.allocateFrom("/mount/point"));
 				return 0;
 			});
 
@@ -129,7 +129,7 @@ public class FlushFsyncFsyncdir {
 		@DisplayName("flush(\"/foo\", fi)")
 		public void testFlush() {
 			try (var arena = Arena.ofConfined()) {
-				var path = arena.allocateUtf8String("/foo");
+				var path = arena.allocateFrom("/foo");
 				var fi = fuse_file_info.allocate(arena);
 				Mockito.doReturn(42).when(fuseOps).flush(Mockito.eq("/foo"), Mockito.any());
 
@@ -143,7 +143,7 @@ public void testFlush() {
 		@DisplayName("fsync(\"/foo\", 1, fi)")
 		public void testFsync() {
 			try (var arena = Arena.ofConfined()) {
-				var path = arena.allocateUtf8String("/foo");
+				var path = arena.allocateFrom("/foo");
 				var fi = fuse_file_info.allocate(arena);
 				Mockito.doReturn(42).when(fuseOps).fsync(Mockito.eq("/foo"), Mockito.eq(1), Mockito.any());
 
@@ -157,7 +157,7 @@ public void testFsync() {
 		@DisplayName("fsyncdir(\"/foo\", 1, fi)")
 		public void testFsyncdir() {
 			try (var arena = Arena.ofConfined()) {
-				var path = arena.allocateUtf8String("/foo");
+				var path = arena.allocateFrom("/foo");
 				var fi = fuse_file_info.allocate(arena);
 				Mockito.doReturn(42).when(fuseOps).fsyncdir(Mockito.eq("/foo"), Mockito.eq(1), Mockito.any());
 
@@ -196,8 +196,8 @@ public class Utimens {
 		@Test
 		public void testUtimensNow() {
 			try (var arena = Arena.ofConfined()) {
-				var path = arena.allocateUtf8String("/foo");
-				var fi = arena.allocate(fuse_file_info.$LAYOUT());
+				var path = arena.allocateFrom("/foo");
+				var fi = fuse_file_info.allocate(arena);
 				var times = MemorySegment.NULL;
 				Mockito.doReturn(42).when(fuseOps).utimens(Mockito.eq("/foo"), Mockito.argThat(TimeSpec::isUtimeNow), Mockito.argThat(TimeSpec::isUtimeNow), Mockito.any());
 
@@ -217,13 +217,13 @@ public void testUtimens(long sec0, long nsec0, long sec1, long nsec1) {
 			Instant expectedATime = Instant.ofEpochSecond(sec0, nsec0);
 			Instant expectedMTime = Instant.ofEpochSecond(sec1, nsec1);
 			try (var arena = Arena.ofConfined()) {
-				var path = arena.allocateUtf8String("/foo");
-				var fi = arena.allocate(fuse_file_info.$LAYOUT());
+				var path = arena.allocateFrom("/foo");
+				var fi = fuse_file_info.allocate(arena);
 				var times = timespec.allocateArray(2, arena);
-				timespec.tv_sec$set(times, 0, sec0);
-				timespec.tv_nsec$set(times, 0, nsec0);
-				timespec.tv_sec$set(times, 1, sec1);
-				timespec.tv_nsec$set(times, 1, nsec1);
+				timespec.tv_sec(timespec.asSlice(times, 0), sec0);
+				timespec.tv_nsec(timespec.asSlice(times, 0), nsec0);
+				timespec.tv_sec(timespec.asSlice(times, 1), sec1);
+				timespec.tv_nsec(timespec.asSlice(times, 1), nsec1);
 				Mockito.doReturn(42).when(fuseOps).utimens(Mockito.eq("/foo"), Mockito.argThat(t -> expectedATime.equals(t.get())), Mockito.argThat(t -> expectedMTime.equals(t.get())), Mockito.any());
 
 				var result = fuseImpl.utimens(path, times, fi);
@@ -241,8 +241,8 @@ public class Attr {
 		@DisplayName("getxattr")
 		public void testGetxattr() {
 			try (var arena = Arena.ofConfined()) {
-				var path = arena.allocateUtf8String("/foo");
-				var name = arena.allocateUtf8String("bar");
+				var path = arena.allocateFrom("/foo");
+				var name = arena.allocateFrom("bar");
 				var value = arena.allocate(100);
 
 				Mockito.doReturn(42).when(fuseOps).getxattr(Mockito.eq("/foo"), Mockito.eq("bar"), Mockito.any());
@@ -257,8 +257,8 @@ public void testGetxattr() {
 		@DisplayName("setxattr")
 		public void testSetxattr() {
 			try (var arena = Arena.ofConfined()) {
-				var path = arena.allocateUtf8String("/foo");
-				var name = arena.allocateUtf8String("bar");
+				var path = arena.allocateFrom("/foo");
+				var name = arena.allocateFrom("bar");
 				var value = arena.allocate(100);
 
 				Mockito.doReturn(42).when(fuseOps).setxattr(Mockito.eq("/foo"), Mockito.eq("bar"), Mockito.any(), Mockito.anyInt());
@@ -273,7 +273,7 @@ public void testSetxattr() {
 		@DisplayName("listxattr")
 		public void testListxattr() {
 			try (var arena = Arena.ofConfined()) {
-				var path = arena.allocateUtf8String("/foo");
+				var path = arena.allocateFrom("/foo");
 				var list = arena.allocate(100);
 
 				Mockito.doReturn(42).when(fuseOps).listxattr(Mockito.eq("/foo"), Mockito.any());
@@ -288,8 +288,8 @@ public void testListxattr() {
 		@DisplayName("removexattr")
 		public void testRemovexattr() {
 			try (var arena = Arena.ofConfined()) {
-				var path = arena.allocateUtf8String("/foo");
-				var name = arena.allocateUtf8String("bar");
+				var path = arena.allocateFrom("/foo");
+				var name = arena.allocateFrom("bar");
 
 				Mockito.doReturn(42).when(fuseOps).removexattr(Mockito.eq("/foo"), Mockito.eq("bar"));
 
@@ -305,7 +305,7 @@ public void testRemovexattr() {
 	@DisplayName("chown")
 	public void testChown() {
 		try (var arena = Arena.ofConfined()) {
-			var path = arena.allocateUtf8String("/foo");
+			var path = arena.allocateFrom("/foo");
 			var fi = fuse_file_info.allocate(arena);
 			Mockito.doReturn(42).when(fuseOps).chown(Mockito.eq("/foo"), Mockito.eq(42), Mockito.eq(1337), Mockito.any());
 
diff --git a/jfuse-linux-amd64/src/test/java/org/cryptomator/jfuse/linux/amd64/StatImplTest.java b/jfuse-linux-amd64/src/test/java/org/cryptomator/jfuse/linux/amd64/StatImplTest.java
index 352bd598..ca1d0dd3 100644
--- a/jfuse-linux-amd64/src/test/java/org/cryptomator/jfuse/linux/amd64/StatImplTest.java
+++ b/jfuse-linux-amd64/src/test/java/org/cryptomator/jfuse/linux/amd64/StatImplTest.java
@@ -23,7 +23,7 @@ public class StatImplTest {
 	public void testGetters(SetInMemorySegment<Number> setter, GetInStat<Number> getter, Number value) {
 		try (var arena = Arena.ofConfined()) {
 			var segment = stat.allocate(arena);
-			var stat = new StatImpl(segment, arena);
+			var stat = new StatImpl(segment);
 
 			setter.accept(segment, value);
 
@@ -33,11 +33,11 @@ public void testGetters(SetInMemorySegment<Number> setter, GetInStat<Number> get
 
 	public static Stream<Arguments> testGetters() {
 		return Stream.of(
-				Arguments.arguments((SetInMemorySegment<Integer>) stat::st_mode$set, Named.of("getMode()", (GetInStat<Integer>) Stat::getMode), 42),
-				Arguments.arguments((SetInMemorySegment<Integer>) stat::st_uid$set, Named.of("getUid()", (GetInStat<Integer>) Stat::getUid), 42),
-				Arguments.arguments((SetInMemorySegment<Integer>) stat::st_gid$set, Named.of("getGid()", (GetInStat<Integer>) Stat::getGid), 42),
-				Arguments.arguments((SetInMemorySegment<Long>) stat::st_nlink$set, Named.of("getNLink()", (GetInStat<Long>) Stat::getNLink), 42L),
-				Arguments.arguments((SetInMemorySegment<Long>) stat::st_size$set, Named.of("getSize()", (GetInStat<Long>) Stat::getSize), 42L)
+				Arguments.arguments((SetInMemorySegment<Integer>) stat::st_mode, Named.of("getMode()", (GetInStat<Integer>) Stat::getMode), 42),
+				Arguments.arguments((SetInMemorySegment<Integer>) stat::st_uid, Named.of("getUid()", (GetInStat<Integer>) Stat::getUid), 42),
+				Arguments.arguments((SetInMemorySegment<Integer>) stat::st_gid, Named.of("getGid()", (GetInStat<Integer>) Stat::getGid), 42),
+				Arguments.arguments((SetInMemorySegment<Long>) stat::st_nlink, Named.of("getNLink()", (GetInStat<Long>) Stat::getNLink), 42L),
+				Arguments.arguments((SetInMemorySegment<Long>) stat::st_size, Named.of("getSize()", (GetInStat<Long>) Stat::getSize), 42L)
 		);
 	}
 
@@ -51,7 +51,7 @@ private interface GetInStat<T> extends Function<Stat, T> {}
 	public void testSetters(SetInStat<Number> setter, GetInMemorySegment<Number> getter, Number value) {
 		try (var arena = Arena.ofConfined()) {
 			var segment = stat.allocate(arena);
-			var stat = new StatImpl(segment, arena);
+			var stat = new StatImpl(segment);
 
 			setter.accept(stat, value);
 
@@ -61,11 +61,11 @@ public void testSetters(SetInStat<Number> setter, GetInMemorySegment<Number> get
 
 	public static Stream<Arguments> testSetters() {
 		return Stream.of(
-				Arguments.arguments(Named.of("setMode()", (SetInStat<Integer>) Stat::setMode), (GetInMemorySegment<Integer>) stat::st_mode$get, 42),
-				Arguments.arguments(Named.of("setUid()", (SetInStat<Integer>) Stat::setUid), (GetInMemorySegment<Integer>) stat::st_uid$get, 42),
-				Arguments.arguments(Named.of("setGid()", (SetInStat<Integer>) Stat::setGid), (GetInMemorySegment<Integer>) stat::st_gid$get, 42),
-				Arguments.arguments(Named.of("setNLink()", (SetInStat<Short>) Stat::setNLink), (GetInMemorySegment<Long>) stat::st_nlink$get, (short) 42),
-				Arguments.arguments(Named.of("setSize()", (SetInStat<Long>) Stat::setSize), (GetInMemorySegment<Long>) stat::st_size$get, 42L)
+				Arguments.arguments(Named.of("setMode()", (SetInStat<Integer>) Stat::setMode), (GetInMemorySegment<Integer>) stat::st_mode, 42),
+				Arguments.arguments(Named.of("setUid()", (SetInStat<Integer>) Stat::setUid), (GetInMemorySegment<Integer>) stat::st_uid, 42),
+				Arguments.arguments(Named.of("setGid()", (SetInStat<Integer>) Stat::setGid), (GetInMemorySegment<Integer>) stat::st_gid, 42),
+				Arguments.arguments(Named.of("setNLink()", (SetInStat<Short>) Stat::setNLink), (GetInMemorySegment<Long>) stat::st_nlink, (short) 42),
+				Arguments.arguments(Named.of("setSize()", (SetInStat<Long>) Stat::setSize), (GetInMemorySegment<Long>) stat::st_size, 42L)
 		);
 	}
 
diff --git a/jfuse-linux-amd64/src/test/java/org/cryptomator/jfuse/linux/amd64/TimeSpecImplTest.java b/jfuse-linux-amd64/src/test/java/org/cryptomator/jfuse/linux/amd64/TimeSpecImplTest.java
index ea1ad14d..8816d028 100644
--- a/jfuse-linux-amd64/src/test/java/org/cryptomator/jfuse/linux/amd64/TimeSpecImplTest.java
+++ b/jfuse-linux-amd64/src/test/java/org/cryptomator/jfuse/linux/amd64/TimeSpecImplTest.java
@@ -16,8 +16,8 @@ public class TimeSpecImplTest {
 	public void testGet() {
 		try (var arena = Arena.ofConfined()) {
 			var timeSpec = new TimeSpecImpl(timespec.allocate(arena));
-			timespec.tv_sec$set(timeSpec.segment(), 123L);
-			timespec.tv_nsec$set(timeSpec.segment(), 456L);
+			timespec.tv_sec(timeSpec.segment(), 123L);
+			timespec.tv_nsec(timeSpec.segment(), 456L);
 
 			var result = timeSpec.get();
 
@@ -31,13 +31,13 @@ public void testGet() {
 	public void testSet() {
 		try (var arena = Arena.ofConfined()) {
 			var timeSpec = new TimeSpecImpl(timespec.allocate(arena));
-			timespec.tv_sec$set(timeSpec.segment(), 0L);
-			timespec.tv_nsec$set(timeSpec.segment(), 0L);
+			timespec.tv_sec(timeSpec.segment(), 0L);
+			timespec.tv_nsec(timeSpec.segment(), 0L);
 
 			timeSpec.set(Instant.ofEpochSecond(123L, 456L));
 
-			Assertions.assertEquals(123L, timespec.tv_sec$get(timeSpec.segment()));
-			Assertions.assertEquals(456L, timespec.tv_nsec$get(timeSpec.segment()));
+			Assertions.assertEquals(123L, timespec.tv_sec(timeSpec.segment()));
+			Assertions.assertEquals(456L, timespec.tv_nsec(timeSpec.segment()));
 		}
 	}
 
@@ -46,8 +46,8 @@ public void testSet() {
 	public void testIsUtimeOmit() {
 		try (var arena = Arena.ofConfined()) {
 			var timeSpec = new TimeSpecImpl(timespec.allocate(arena));
-			timespec.tv_sec$set(timeSpec.segment(), 123L);
-			timespec.tv_nsec$set(timeSpec.segment(), stat_h.UTIME_OMIT());
+			timespec.tv_sec(timeSpec.segment(), 123L);
+			timespec.tv_nsec(timeSpec.segment(), stat_h.UTIME_OMIT());
 
 			Assertions.assertTrue(timeSpec.isUtimeOmit());
 			Assertions.assertFalse(timeSpec.isUtimeNow());
@@ -59,8 +59,8 @@ public void testIsUtimeOmit() {
 	public void testIsUtimeNow() {
 		try (var arena = Arena.ofConfined()) {
 			var timeSpec = new TimeSpecImpl(timespec.allocate(arena));
-			timespec.tv_sec$set(timeSpec.segment(), 123L);
-			timespec.tv_nsec$set(timeSpec.segment(), stat_h.UTIME_NOW());
+			timespec.tv_sec(timeSpec.segment(), 123L);
+			timespec.tv_nsec(timeSpec.segment(), stat_h.UTIME_NOW());
 
 			Assertions.assertFalse(timeSpec.isUtimeOmit());
 			Assertions.assertTrue(timeSpec.isUtimeNow());
diff --git a/jfuse-mac/pom.xml b/jfuse-mac/pom.xml
index e1f95d67..8a1c1fe7 100644
--- a/jfuse-mac/pom.xml
+++ b/jfuse-mac/pom.xml
@@ -31,7 +31,7 @@
 				<groupId>org.apache.maven.plugins</groupId>
 				<artifactId>maven-surefire-plugin</artifactId>
 				<configuration>
-					<argLine>@{surefire.jacoco.args} -javaagent:${net.bytebuddy:byte-buddy-agent:jar} --enable-preview --enable-native-access=org.cryptomator.jfuse.mac</argLine>
+					<argLine>@{surefire.jacoco.args} -javaagent:${net.bytebuddy:byte-buddy-agent:jar} --enable-native-access=org.cryptomator.jfuse.mac</argLine>
 				</configuration>
 			</plugin>
 		</plugins>
@@ -81,7 +81,7 @@
 					<plugin>
 						<groupId>io.github.coffeelibs</groupId>
 						<artifactId>jextract-maven-plugin</artifactId>
-						<version>0.3.0</version>
+						<version>0.4.0</version>
 						<configuration>
 							<executable>/Users/sebastian/git/github.com/openjdk/jextract/build/jextract/bin/jextract</executable>
 							<headerSearchPaths>${mac.headerSearchPath}</headerSearchPaths>
diff --git a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/DirFillerImpl.java b/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/DirFillerImpl.java
index b905fc45..b167517b 100644
--- a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/DirFillerImpl.java
+++ b/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/DirFillerImpl.java
@@ -9,17 +9,13 @@
 import java.lang.foreign.MemorySegment;
 import java.util.function.Consumer;
 
-record DirFillerImpl(MemorySegment buf, fuse_fill_dir_t callback, Arena arena) implements DirFiller {
-
-	DirFillerImpl(MemorySegment buf, MemorySegment callback, Arena arena) {
-		this(buf, fuse_fill_dir_t.ofAddress(callback, arena), arena);
-	}
+record DirFillerImpl(MemorySegment buf, MemorySegment callback, Arena arena) implements DirFiller {
 
 	@Override
 	public int fill(String name, Consumer<Stat> statFiller, long offset, int flags) {
 		var statSegment = stat.allocate(arena);
 		statFiller.accept(new StatImpl(statSegment));
-		return callback.apply(buf, arena.allocateUtf8String(name), statSegment, offset);
+		return fuse_fill_dir_t.invoke(callback, buf, arena.allocateFrom(name), statSegment, offset);
 	}
 
 }
\ No newline at end of file
diff --git a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/FileInfoImpl.java b/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/FileInfoImpl.java
index e29b1f42..fd5d5729 100644
--- a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/FileInfoImpl.java
+++ b/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/FileInfoImpl.java
@@ -22,23 +22,19 @@ record FileInfoImpl(MemorySegment segment) implements FileInfo {
 	private static final int O_SYNC = fcntl_h.O_SYNC();
 	private static final int O_DSYNC = fcntl_h.O_DSYNC();
 
-	public FileInfoImpl(MemorySegment address, Arena scope) {
-		this(fuse_file_info.ofAddress(address, scope));
-	}
-
 	@Override
 	public long getFh() {
-		return fuse_file_info.fh$get(segment);
+		return fuse_file_info.fh(segment);
 	}
 
 	@Override
 	public void setFh(long fh) {
-		fuse_file_info.fh$set(segment, fh);
+		fuse_file_info.fh(segment, fh);
 	}
 
 	@Override
 	public int getFlags() {
-		return fuse_file_info.flags$get(segment);
+		return fuse_file_info.flags(segment);
 	}
 
 	@Override
@@ -78,7 +74,7 @@ public Set<StandardOpenOption> getOpenFlags() {
 
 	@Override
 	public long getLockOwner() {
-		return fuse_file_info.lock_owner$get(segment);
+		return fuse_file_info.lock_owner(segment);
 	}
 
 }
diff --git a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/FuseArgs.java b/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/FuseArgs.java
index 11cc667a..94c090da 100644
--- a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/FuseArgs.java
+++ b/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/FuseArgs.java
@@ -10,13 +10,13 @@ record FuseArgs(MemorySegment args, MemorySegment mountPoint, boolean multiThrea
 	@Override
 	public String toString() {
 		var sb = new StringBuilder();
-		var argc = fuse_args.argc$get(args);
-		var argv = fuse_args.argv$get(args);
+		var argc = fuse_args.argc(args);
+		var argv = fuse_args.argv(args);
 		for (int i = 0; i < argc; i++) {
 			var cString = argv.getAtIndex(ValueLayout.ADDRESS, i).reinterpret(Long.MAX_VALUE);
-			sb.append("arg[").append(i).append("] = ").append(cString.getUtf8String(0)).append(", ");
+			sb.append("arg[").append(i).append("] = ").append(cString.getString(0)).append(", ");
 		}
-		sb.append("mountPoint = ").append(mountPoint.getUtf8String(0)).append(", ");
+		sb.append("mountPoint = ").append(mountPoint.getString(0)).append(", ");
 		sb.append("multiThreaded = ").append(multiThreaded);
 		return sb.toString();
 	}
diff --git a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/FuseConnInfoImpl.java b/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/FuseConnInfoImpl.java
index 4efffc90..4ccacdb9 100644
--- a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/FuseConnInfoImpl.java
+++ b/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/FuseConnInfoImpl.java
@@ -8,81 +8,77 @@
 
 record FuseConnInfoImpl(MemorySegment segment) implements FuseConnInfo {
 
-	public FuseConnInfoImpl(MemorySegment address, Arena scope) {
-		this(fuse_conn_info.ofAddress(address, scope));
-	}
-
 	@Override
 	public int protoMajor() {
-		return fuse_conn_info.proto_major$get(segment);
+		return fuse_conn_info.proto_major(segment);
 	}
 
 	@Override
 	public int protoMinor() {
-		return fuse_conn_info.proto_minor$get(segment);
+		return fuse_conn_info.proto_minor(segment);
 	}
 	@Override
 	public int capable() {
-		return fuse_conn_info.capable$get(segment);
+		return fuse_conn_info.capable(segment);
 	}
 
 	@Override
 	public int want() {
-		return fuse_conn_info.want$get(segment);
+		return fuse_conn_info.want(segment);
 	}
 	@Override
 	public void setWant(int wanted) {
-		fuse_conn_info.want$set(segment, wanted);
+		fuse_conn_info.want(segment, wanted);
 	}
 
 	@Override
 	public int maxWrite() {
-		return fuse_conn_info.max_write$get(segment);
+		return fuse_conn_info.max_write(segment);
 	}
 
 	@Override
 	public void setMaxWrite(int maxWrite) {
-		fuse_conn_info.max_write$set(segment, maxWrite);
+		fuse_conn_info.max_write(segment, maxWrite);
 	}
 
 	@Override
 	public int maxReadahead() {
-		return fuse_conn_info.max_readahead$get(segment);
+		return fuse_conn_info.max_readahead(segment);
 	}
 
 	@Override
 	public void setMaxReadahead(int maxReadahead) {
-		fuse_conn_info.max_readahead$set(segment, maxReadahead);
+		fuse_conn_info.max_readahead(segment, maxReadahead);
 	}
 
 	@Override
 	public int maxBackground() {
-		return fuse_conn_info.max_background$get(segment);
+		return fuse_conn_info.max_background(segment);
 	}
 
 	@Override
 	public void setMaxBackground(int maxBackground) {
-		fuse_conn_info.max_background$set(segment, maxBackground);
+		fuse_conn_info.max_background(segment, maxBackground);
 	}
 
 	@Override
 	public int congestionThreshold() {
-		return fuse_conn_info.congestion_threshold$get(segment);
+		return fuse_conn_info.congestion_threshold(segment);
 	}
 
 	@Override
 	public void setCongestionThreshold(int congestionThreshold) {
-		fuse_conn_info.congestion_threshold$set(segment, congestionThreshold);
+		fuse_conn_info.congestion_threshold(segment, congestionThreshold);
 	}
 
 	@Override
 	public int asyncRead() {
-		return fuse_conn_info.async_read$get(segment);
+		return fuse_conn_info.async_read(segment);
 	}
 
 	@Override
 	public void setAsyncRead(int asyncRead) {
-		fuse_conn_info.async_read$set(segment, asyncRead);
+		fuse_conn_info.async_read(segment, asyncRead);
 	}
 
 }
diff --git a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/FuseImpl.java b/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/FuseImpl.java
index 58232d94..047ae6f0 100644
--- a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/FuseImpl.java
+++ b/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/FuseImpl.java
@@ -44,15 +44,15 @@ protected FuseMount mount(List<String> args) throws FuseMountFailedException {
 	FuseArgs parseArgs(List<String> cmdLineArgs) throws IllegalArgumentException {
 		var args = fuse_args.allocate(fuseArena);
 		var argc = cmdLineArgs.size();
-		var argv = fuseArena.allocateArray(ValueLayout.ADDRESS, argc + 1L);
+		var argv = fuseArena.allocate(ValueLayout.ADDRESS, argc + 1L);
 		for (int i = 0; i < argc; i++) {
-			var cString = fuseArena.allocateUtf8String(cmdLineArgs.get(i));
+			var cString = fuseArena.allocateFrom(cmdLineArgs.get(i));
 			argv.setAtIndex(ValueLayout.ADDRESS, i, cString);
 		}
 		argv.setAtIndex(ValueLayout.ADDRESS, argc, MemorySegment.NULL);
-		fuse_args.argc$set(args, argc);
-		fuse_args.argv$set(args, argv);
-		fuse_args.allocated$set(args, 0);
+		fuse_args.argc(args, argc);
+		fuse_args.argv(args, argv);
+		fuse_args.allocated(args, 0);
 
 		var multithreaded = fuseArena.allocate(JAVA_INT, 1);
 		var foreground = fuseArena.allocate(JAVA_INT, 1);
@@ -69,69 +69,65 @@ FuseArgs parseArgs(List<String> cmdLineArgs) throws IllegalArgumentException {
 	@Override
 	protected void bind(FuseOperations.Operation operation) {
 		switch (operation) {
-			case INIT -> fuse_operations.init$set(fuseOperationsStruct, fuse_operations.init.allocate(this::init, fuseArena));
-			case ACCESS -> fuse_operations.access$set(fuseOperationsStruct, fuse_operations.access.allocate(this::access, fuseArena));
-			case CHMOD -> fuse_operations.chmod$set(fuseOperationsStruct, fuse_operations.chmod.allocate(this::chmod, fuseArena));
-			case CHOWN -> fuse_operations.chown$set(fuseOperationsStruct, fuse_operations.chown.allocate(this::chown, fuseArena));
-			case CREATE -> fuse_operations.create$set(fuseOperationsStruct, fuse_operations.create.allocate(this::create, fuseArena));
-			case DESTROY -> fuse_operations.destroy$set(fuseOperationsStruct, fuse_operations.destroy.allocate(this::destroy, fuseArena));
-			case FLUSH -> fuse_operations.flush$set(fuseOperationsStruct, fuse_operations.flush.allocate(this::flush, fuseArena));
-			case FSYNC -> fuse_operations.fsync$set(fuseOperationsStruct, fuse_operations.fsync.allocate(this::fsync, fuseArena));
-			case FSYNCDIR -> fuse_operations.fsyncdir$set(fuseOperationsStruct, fuse_operations.fsyncdir.allocate(this::fsyncdir, fuseArena));
+			case INIT -> fuse_operations.init(fuseOperationsStruct, fuse_operations.init.allocate(this::init, fuseArena));
+			case ACCESS -> fuse_operations.access(fuseOperationsStruct, fuse_operations.access.allocate(this::access, fuseArena));
+			case CHMOD -> fuse_operations.chmod(fuseOperationsStruct, fuse_operations.chmod.allocate(this::chmod, fuseArena));
+			case CHOWN -> fuse_operations.chown(fuseOperationsStruct, fuse_operations.chown.allocate(this::chown, fuseArena));
+			case CREATE -> fuse_operations.create(fuseOperationsStruct, fuse_operations.create.allocate(this::create, fuseArena));
+			case DESTROY -> fuse_operations.destroy(fuseOperationsStruct, fuse_operations.destroy.allocate(this::destroy, fuseArena));
+			case FLUSH -> fuse_operations.flush(fuseOperationsStruct, fuse_operations.flush.allocate(this::flush, fuseArena));
+			case FSYNC -> fuse_operations.fsync(fuseOperationsStruct, fuse_operations.fsync.allocate(this::fsync, fuseArena));
+			case FSYNCDIR -> fuse_operations.fsyncdir(fuseOperationsStruct, fuse_operations.fsyncdir.allocate(this::fsyncdir, fuseArena));
 			case GET_ATTR -> {
-				fuse_operations.getattr$set(fuseOperationsStruct, fuse_operations.getattr.allocate(this::getattr, fuseArena));
-				fuse_operations.fgetattr$set(fuseOperationsStruct, fuse_operations.fgetattr.allocate(this::fgetattr, fuseArena));
+				fuse_operations.getattr(fuseOperationsStruct, fuse_operations.getattr.allocate(this::getattr, fuseArena));
+				fuse_operations.fgetattr(fuseOperationsStruct, fuse_operations.fgetattr.allocate(this::fgetattr, fuseArena));
 			}
-			case GET_XATTR -> fuse_operations.getxattr$set(fuseOperationsStruct, fuse_operations.getxattr.allocate(this::getxattr, fuseArena));
-			case LIST_XATTR -> fuse_operations.listxattr$set(fuseOperationsStruct, fuse_operations.listxattr.allocate(this::listxattr, fuseArena));
-			case MKDIR -> fuse_operations.mkdir$set(fuseOperationsStruct, fuse_operations.mkdir.allocate(this::mkdir, fuseArena));
-			case OPEN -> fuse_operations.open$set(fuseOperationsStruct, fuse_operations.open.allocate(this::open, fuseArena));
-			case OPEN_DIR -> fuse_operations.opendir$set(fuseOperationsStruct, fuse_operations.opendir.allocate(this::opendir, fuseArena));
-			case READ -> fuse_operations.read$set(fuseOperationsStruct, fuse_operations.read.allocate(this::read, fuseArena));
-			case READ_DIR -> fuse_operations.readdir$set(fuseOperationsStruct, fuse_operations.readdir.allocate(this::readdir, fuseArena));
-			case READLINK -> fuse_operations.readlink$set(fuseOperationsStruct, fuse_operations.readlink.allocate(this::readlink, fuseArena));
-			case RELEASE -> fuse_operations.release$set(fuseOperationsStruct, fuse_operations.release.allocate(this::release, fuseArena));
-			case RELEASE_DIR -> fuse_operations.releasedir$set(fuseOperationsStruct, fuse_operations.releasedir.allocate(this::releasedir, fuseArena));
-			case REMOVE_XATTR -> fuse_operations.removexattr$set(fuseOperationsStruct, fuse_operations.removexattr.allocate(this::removexattr, fuseArena));
-			case RENAME -> fuse_operations.rename$set(fuseOperationsStruct, fuse_operations.rename.allocate(this::rename, fuseArena));
-			case RMDIR -> fuse_operations.rmdir$set(fuseOperationsStruct, fuse_operations.rmdir.allocate(this::rmdir, fuseArena));
-			case SET_XATTR -> fuse_operations.setxattr$set(fuseOperationsStruct, fuse_operations.setxattr.allocate(this::setxattr, fuseArena));
-			case STATFS -> fuse_operations.statfs$set(fuseOperationsStruct, fuse_operations.statfs.allocate(this::statfs, fuseArena));
-			case SYMLINK -> fuse_operations.symlink$set(fuseOperationsStruct, fuse_operations.symlink.allocate(this::symlink, fuseArena));
+			case GET_XATTR -> fuse_operations.getxattr(fuseOperationsStruct, fuse_operations.getxattr.allocate(this::getxattr, fuseArena));
+			case LIST_XATTR -> fuse_operations.listxattr(fuseOperationsStruct, fuse_operations.listxattr.allocate(this::listxattr, fuseArena));
+			case MKDIR -> fuse_operations.mkdir(fuseOperationsStruct, fuse_operations.mkdir.allocate(this::mkdir, fuseArena));
+			case OPEN -> fuse_operations.open(fuseOperationsStruct, fuse_operations.open.allocate(this::open, fuseArena));
+			case OPEN_DIR -> fuse_operations.opendir(fuseOperationsStruct, fuse_operations.opendir.allocate(this::opendir, fuseArena));
+			case READ -> fuse_operations.read(fuseOperationsStruct, fuse_operations.read.allocate(this::read, fuseArena));
+			case READ_DIR -> fuse_operations.readdir(fuseOperationsStruct, fuse_operations.readdir.allocate(this::readdir, fuseArena));
+			case READLINK -> fuse_operations.readlink(fuseOperationsStruct, fuse_operations.readlink.allocate(this::readlink, fuseArena));
+			case RELEASE -> fuse_operations.release(fuseOperationsStruct, fuse_operations.release.allocate(this::release, fuseArena));
+			case RELEASE_DIR -> fuse_operations.releasedir(fuseOperationsStruct, fuse_operations.releasedir.allocate(this::releasedir, fuseArena));
+			case REMOVE_XATTR -> fuse_operations.removexattr(fuseOperationsStruct, fuse_operations.removexattr.allocate(this::removexattr, fuseArena));
+			case RENAME -> fuse_operations.rename(fuseOperationsStruct, fuse_operations.rename.allocate(this::rename, fuseArena));
+			case RMDIR -> fuse_operations.rmdir(fuseOperationsStruct, fuse_operations.rmdir.allocate(this::rmdir, fuseArena));
+			case SET_XATTR -> fuse_operations.setxattr(fuseOperationsStruct, fuse_operations.setxattr.allocate(this::setxattr, fuseArena));
+			case STATFS -> fuse_operations.statfs(fuseOperationsStruct, fuse_operations.statfs.allocate(this::statfs, fuseArena));
+			case SYMLINK -> fuse_operations.symlink(fuseOperationsStruct, fuse_operations.symlink.allocate(this::symlink, fuseArena));
 			case TRUNCATE -> {
-				fuse_operations.truncate$set(fuseOperationsStruct, fuse_operations.truncate.allocate(this::truncate, fuseArena));
-				fuse_operations.ftruncate$set(fuseOperationsStruct, fuse_operations.ftruncate.allocate(this::ftruncate, fuseArena));
+				fuse_operations.truncate(fuseOperationsStruct, fuse_operations.truncate.allocate(this::truncate, fuseArena));
+				fuse_operations.ftruncate(fuseOperationsStruct, fuse_operations.ftruncate.allocate(this::ftruncate, fuseArena));
 			}
-			case UNLINK -> fuse_operations.unlink$set(fuseOperationsStruct, fuse_operations.unlink.allocate(this::unlink, fuseArena));
-			case UTIMENS -> fuse_operations.utimens$set(fuseOperationsStruct, fuse_operations.utimens.allocate(this::utimens, fuseArena));
-			case WRITE -> fuse_operations.write$set(fuseOperationsStruct, fuse_operations.write.allocate(this::write, fuseArena));
+			case UNLINK -> fuse_operations.unlink(fuseOperationsStruct, fuse_operations.unlink.allocate(this::unlink, fuseArena));
+			case UTIMENS -> fuse_operations.utimens(fuseOperationsStruct, fuse_operations.utimens.allocate(this::utimens, fuseArena));
+			case WRITE -> fuse_operations.write(fuseOperationsStruct, fuse_operations.write.allocate(this::write, fuseArena));
 		}
 	}
 
 	private MemorySegment init(MemorySegment conn) {
-		try (var arena = Arena.ofConfined()) {
-			fuseOperations.init(new FuseConnInfoImpl(conn, arena), null);
-		}
+		fuseOperations.init(new FuseConnInfoImpl(conn), null);
 		return MemorySegment.NULL;
 	}
 
 	private int access(MemorySegment path, int mask) {
-		return fuseOperations.access(path.getUtf8String(0), mask);
+		return fuseOperations.access(path.getString(0), mask);
 	}
 
 	private int chmod(MemorySegment path, short mode) {
-		return fuseOperations.chmod(path.getUtf8String(0), mode, null);
+		return fuseOperations.chmod(path.getString(0), mode, null);
 	}
 
 	@VisibleForTesting
 	int chown(MemorySegment path, int uid, int gid) {
-		return fuseOperations.chown(path.getUtf8String(0), uid, gid, null);
+		return fuseOperations.chown(path.getString(0), uid, gid, null);
 	}
 
 	private int create(MemorySegment path, short mode, MemorySegment fi) {
-		try (var arena = Arena.ofConfined()) {
-			return fuseOperations.create(path.getUtf8String(0), mode, new FileInfoImpl(fi, arena));
-		}
+		return fuseOperations.create(path.getString(0), mode, new FileInfoImpl(fi));
 	}
 
 	private void destroy(MemorySegment addr) {
@@ -140,140 +136,116 @@ private void destroy(MemorySegment addr) {
 
 	@VisibleForTesting
 	int flush(MemorySegment path, MemorySegment fi) {
-		try (var arena = Arena.ofConfined()) {
-			return fuseOperations.flush(path.getUtf8String(0), new FileInfoImpl(fi, arena));
-		}
+		return fuseOperations.flush(path.getString(0), new FileInfoImpl(fi));
 	}
 
 	@VisibleForTesting
 	int fsync(MemorySegment path, int datasync, MemorySegment fi) {
-		try (var arena = Arena.ofConfined()) {
-			return fuseOperations.fsync(path.getUtf8String(0), datasync, new FileInfoImpl(fi, arena));
-		}
+		return fuseOperations.fsync(path.getString(0), datasync, new FileInfoImpl(fi));
 	}
 
 	@VisibleForTesting
 	int fsyncdir(MemorySegment path, int datasync, MemorySegment fi) {
-		try (var arena = Arena.ofConfined()) {
-			return fuseOperations.fsyncdir(MemoryUtils.toUtf8StringOrNull(path), datasync, new FileInfoImpl(fi, arena));
-		}
+		return fuseOperations.fsyncdir(MemoryUtils.toUtf8StringOrNull(path), datasync, new FileInfoImpl(fi));
 	}
 
 	@VisibleForTesting
 	int getattr(MemorySegment path, MemorySegment stat) {
-		try (var arena = Arena.ofConfined()) {
-			return fuseOperations.getattr(path.getUtf8String(0), new StatImpl(stat, arena), null);
-		}
+		return fuseOperations.getattr(path.getString(0), new StatImpl(stat), null);
 	}
 
 	@VisibleForTesting
 	int fgetattr(MemorySegment path, MemorySegment stat, MemorySegment fi) {
-		try (var arena = Arena.ofConfined()) {
-			return fuseOperations.getattr(path.getUtf8String(0), new StatImpl(stat, arena), new FileInfoImpl(fi, arena));
-		}
+		return fuseOperations.getattr(path.getString(0), new StatImpl(stat), new FileInfoImpl(fi));
 	}
 
 	@VisibleForTesting
 	int getxattr(MemorySegment path, MemorySegment name, MemorySegment value, long size) {
 		var buffer = value.reinterpret(size).asByteBuffer();
-		return fuseOperations.getxattr(path.getUtf8String(0), name.getUtf8String(0), buffer);
+		return fuseOperations.getxattr(path.getString(0), name.getString(0), buffer);
 	}
 
 	@VisibleForTesting
 	int setxattr(MemorySegment path, MemorySegment name, MemorySegment value, long size, int flags) {
 		var buffer = value.reinterpret(size).asByteBuffer();
-		return fuseOperations.setxattr(path.getUtf8String(0), name.getUtf8String(0), buffer, flags);
+		return fuseOperations.setxattr(path.getString(0), name.getString(0), buffer, flags);
 	}
 
 	@VisibleForTesting
 	int listxattr(MemorySegment path, MemorySegment value, long size) {
 		var buffer = value.reinterpret(size).asByteBuffer();
-		return fuseOperations.listxattr(path.getUtf8String(0), buffer);
+		return fuseOperations.listxattr(path.getString(0), buffer);
 	}
 
 	@VisibleForTesting
 	int removexattr(MemorySegment path, MemorySegment name) {
-		return fuseOperations.removexattr(path.getUtf8String(0), name.getUtf8String(0));
+		return fuseOperations.removexattr(path.getString(0), name.getString(0));
 	}
 
 	private int mkdir(MemorySegment path, short mode) {
-		return fuseOperations.mkdir(path.getUtf8String(0), mode);
+		return fuseOperations.mkdir(path.getString(0), mode);
 	}
 
 	private int open(MemorySegment path, MemorySegment fi) {
-		try (var arena = Arena.ofConfined()) {
-			return fuseOperations.open(path.getUtf8String(0), new FileInfoImpl(fi, arena));
-		}
+		return fuseOperations.open(path.getString(0), new FileInfoImpl(fi));
 	}
 
 	private int opendir(MemorySegment path, MemorySegment fi) {
-		try (var arena = Arena.ofConfined()) {
-			return fuseOperations.opendir(path.getUtf8String(0), new FileInfoImpl(fi, arena));
-		}
+		return fuseOperations.opendir(path.getString(0), new FileInfoImpl(fi));
 	}
 
 	private int read(MemorySegment path, MemorySegment buf, long size, long offset, MemorySegment fi) {
-		try (var arena = Arena.ofConfined()) {
-			var buffer = buf.reinterpret(size).asByteBuffer();
-			return fuseOperations.read(path.getUtf8String(0), buffer, size, offset, new FileInfoImpl(fi, arena));
-		}
+		var buffer = buf.reinterpret(size).asByteBuffer();
+		return fuseOperations.read(path.getString(0), buffer, size, offset, new FileInfoImpl(fi));
 	}
 
 	private int readdir(MemorySegment path, MemorySegment buf, MemorySegment filler, long offset, MemorySegment fi) {
 		try (var arena = Arena.ofConfined()) {
-			return fuseOperations.readdir(path.getUtf8String(0), new DirFillerImpl(buf, filler, arena), offset, new FileInfoImpl(fi, arena), 0);
+			return fuseOperations.readdir(path.getString(0), new DirFillerImpl(buf, filler, arena), offset, new FileInfoImpl(fi), 0);
 		}
 	}
 
 	private int readlink(MemorySegment path, MemorySegment buf, long len) {
 		var buffer = buf.reinterpret(len).asByteBuffer();
-		return fuseOperations.readlink(path.getUtf8String(0), buffer, len);
+		return fuseOperations.readlink(path.getString(0), buffer, len);
 	}
 
 	private int release(MemorySegment path, MemorySegment fi) {
-		try (var arena = Arena.ofConfined()) {
-			return fuseOperations.release(path.getUtf8String(0), new FileInfoImpl(fi, arena));
-		}
+		return fuseOperations.release(path.getString(0), new FileInfoImpl(fi));
 	}
 
 	private int releasedir(MemorySegment path, MemorySegment fi) {
-		try (var arena = Arena.ofConfined()) {
-			return fuseOperations.releasedir(MemoryUtils.toUtf8StringOrNull(path), new FileInfoImpl(fi, arena));
-		}
+		return fuseOperations.releasedir(MemoryUtils.toUtf8StringOrNull(path), new FileInfoImpl(fi));
 	}
 
 	private int rename(MemorySegment oldpath, MemorySegment newpath) {
-		return fuseOperations.rename(oldpath.getUtf8String(0), newpath.getUtf8String(0), 0);
+		return fuseOperations.rename(oldpath.getString(0), newpath.getString(0), 0);
 	}
 
 	private int rmdir(MemorySegment path) {
-		return fuseOperations.rmdir(path.getUtf8String(0));
+		return fuseOperations.rmdir(path.getString(0));
 	}
 
 	private int statfs(MemorySegment path, MemorySegment statvfs) {
-		try (var arena = Arena.ofConfined()) {
-			return fuseOperations.statfs(path.getUtf8String(0), new StatvfsImpl(statvfs, arena));
-		}
+		return fuseOperations.statfs(path.getString(0), new StatvfsImpl(statvfs));
 	}
 
 	private int symlink(MemorySegment linkname, MemorySegment target) {
-		return fuseOperations.symlink(linkname.getUtf8String(0), target.getUtf8String(0));
+		return fuseOperations.symlink(linkname.getString(0), target.getString(0));
 	}
 
 	@VisibleForTesting
 	int truncate(MemorySegment path, long size) {
-		return fuseOperations.truncate(path.getUtf8String(0), size, null);
+		return fuseOperations.truncate(path.getString(0), size, null);
 	}
 
 	@VisibleForTesting
 	int ftruncate(MemorySegment path, long size, MemorySegment fi) {
-		try (var arena = Arena.ofConfined()) {
-			return fuseOperations.truncate(path.getUtf8String(0), size, new FileInfoImpl(fi, arena));
-		}
+		return fuseOperations.truncate(path.getString(0), size, new FileInfoImpl(fi));
 	}
 
 	private int unlink(MemorySegment path) {
-		return fuseOperations.unlink(path.getUtf8String(0));
+		return fuseOperations.unlink(path.getString(0));
 	}
 
 	@VisibleForTesting
@@ -281,24 +253,22 @@ int utimens(MemorySegment path, MemorySegment times) {
 		try (var arena = Arena.ofConfined()) {
 			if (MemorySegment.NULL.equals(times)) {
 				// set both times to current time
-				var segment = arena.allocate(timespec.$LAYOUT());
-				timespec.tv_sec$set(segment, 0);
-				timespec.tv_nsec$set(segment, stat_h.UTIME_NOW());
+				var segment = timespec.allocate(arena);
+				timespec.tv_sec(segment, 0);
+				timespec.tv_nsec(segment, stat_h.UTIME_NOW());
 				var time = new TimeSpecImpl(segment);
-				return fuseOperations.utimens(path.getUtf8String(0), time, time, null);
+				return fuseOperations.utimens(path.getString(0), time, time, null);
 			} else {
-				var time0 = times.asSlice(0, timespec.$LAYOUT().byteSize());
-				var time1 = times.asSlice(timespec.$LAYOUT().byteSize(), timespec.$LAYOUT().byteSize());
-				return fuseOperations.utimens(path.getUtf8String(0), new TimeSpecImpl(time0), new TimeSpecImpl(time1), null);
+				var time0 = timespec.asSlice(times, 0);
+				var time1 = timespec.asSlice(times, 1);
+				return fuseOperations.utimens(path.getString(0), new TimeSpecImpl(time0), new TimeSpecImpl(time1), null);
 			}
 		}
 	}
 
 	private int write(MemorySegment path, MemorySegment buf, long size, long offset, MemorySegment fi) {
-		try (var arena = Arena.ofConfined()) {
-			var buffer = buf.reinterpret(size).asByteBuffer();
-			return fuseOperations.write(path.getUtf8String(0), buffer, size, offset, new FileInfoImpl(fi, arena));
-		}
+		var buffer = buf.reinterpret(size).asByteBuffer();
+		return fuseOperations.write(path.getString(0), buffer, size, offset, new FileInfoImpl(fi));
 	}
 
 }
diff --git a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/StatImpl.java b/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/StatImpl.java
index a6895cf1..57c2f7b6 100644
--- a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/StatImpl.java
+++ b/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/StatImpl.java
@@ -9,78 +9,74 @@
 
 record StatImpl(MemorySegment segment) implements Stat {
 
-	public StatImpl(MemorySegment address, Arena scope) {
-		this(stat.ofAddress(address, scope));
-	}
-
 	@Override
 	public TimeSpec aTime() {
-		return new TimeSpecImpl(stat.st_atimespec$slice(segment));
+		return new TimeSpecImpl(stat.st_atimespec(segment));
 	}
 
 	@Override
 	public TimeSpec cTime() {
-		return new TimeSpecImpl(stat.st_ctimespec$slice(segment));
+		return new TimeSpecImpl(stat.st_ctimespec(segment));
 	}
 
 	@Override
 	public TimeSpec mTime() {
-		return new TimeSpecImpl(stat.st_mtimespec$slice(segment));
+		return new TimeSpecImpl(stat.st_mtimespec(segment));
 	}
 
 	@Override
 	public TimeSpec birthTime() {
-		return new TimeSpecImpl(stat.st_birthtimespec$slice(segment));
+		return new TimeSpecImpl(stat.st_birthtimespec(segment));
 	}
 
 	@Override
 	public void setMode(int mode) {
-		stat.st_mode$set(segment, (short) mode);
+		stat.st_mode(segment, (short) mode);
 	}
 
 	@Override
 	public int getMode() {
-		return stat.st_mode$get(segment);
+		return stat.st_mode(segment);
 	}
 
 	@Override
 	public void setUid(int uid) {
-		stat.st_uid$set(segment, uid);
+		stat.st_uid(segment, uid);
 	}
 
 	@Override
 	public int getUid() {
-		return stat.st_uid$get(segment);
+		return stat.st_uid(segment);
 	}
 
 	@Override
 	public void setGid(int gid) {
-		stat.st_gid$set(segment, gid);
+		stat.st_gid(segment, gid);
 	}
 
 	@Override
 	public int getGid() {
-		return stat.st_gid$get(segment);
+		return stat.st_gid(segment);
 	}
 
 	@Override
 	public void setNLink(short count) {
-		stat.st_nlink$set(segment, count);
+		stat.st_nlink(segment, count);
 	}
 
 	@Override
 	public long getNLink() {
-		return stat.st_nlink$get(segment);
+		return stat.st_nlink(segment);
 	}
 
 	@Override
 	public void setSize(long size) {
-		stat.st_size$set(segment, size);
+		stat.st_size(segment, size);
 	}
 
 	@Override
 	public long getSize() {
-		return stat.st_size$get(segment);
+		return stat.st_size(segment);
 	}
 
 }
diff --git a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/StatvfsImpl.java b/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/StatvfsImpl.java
index feb1bfda..b437bdf5 100644
--- a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/StatvfsImpl.java
+++ b/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/StatvfsImpl.java
@@ -10,68 +10,64 @@ record StatvfsImpl(MemorySegment segment) implements Statvfs {
 
 	private static final long MAX_UINT = 0xFFFFFFFFL;
 
-	public StatvfsImpl(MemorySegment address, Arena scope) {
-		this(statvfs.ofAddress(address, scope));
-	}
-
 	@Override
 	public long getBsize() {
-		return statvfs.f_bsize$get(segment);
+		return statvfs.f_bsize(segment);
 	}
 
 	@Override
 	public void setBsize(long bsize) {
-		statvfs.f_bsize$set(segment, bsize);
+		statvfs.f_bsize(segment, bsize);
 	}
 
 	@Override
 	public long getFrsize() {
-		return statvfs.f_frsize$get(segment);
+		return statvfs.f_frsize(segment);
 	}
 
 	@Override
 	public void setFrsize(long frsize) {
-		statvfs.f_frsize$set(segment, frsize);
+		statvfs.f_frsize(segment, frsize);
 	}
 
 	@Override
 	public long getBlocks() {
-		return Integer.toUnsignedLong(statvfs.f_blocks$get(segment));
+		return Integer.toUnsignedLong(statvfs.f_blocks(segment));
 	}
 
 	@Override
 	public void setBlocks(long blocks) {
-		statvfs.f_blocks$set(segment,(int) Math.min(MAX_UINT, blocks));
+		statvfs.f_blocks(segment,(int) Math.min(MAX_UINT, blocks));
 	}
 
 	@Override
 	public long getBfree() {
-		return Integer.toUnsignedLong(statvfs.f_bfree$get(segment));
+		return Integer.toUnsignedLong(statvfs.f_bfree(segment));
 	}
 
 	@Override
 	public void setBfree(long bfree) {
-		statvfs.f_bfree$set(segment,(int) Math.min(MAX_UINT, bfree));
+		statvfs.f_bfree(segment,(int) Math.min(MAX_UINT, bfree));
 	}
 
 	@Override
 	public long getBavail() {
-		return Integer.toUnsignedLong(statvfs.f_bavail$get(segment));
+		return Integer.toUnsignedLong(statvfs.f_bavail(segment));
 	}
 
 	@Override
 	public void setBavail(long bavail) {
-		statvfs.f_bavail$set(segment,(int) Math.min(MAX_UINT, bavail));
+		statvfs.f_bavail(segment,(int) Math.min(MAX_UINT, bavail));
 	}
 
 	@Override
 	public long getNameMax() {
-		return statvfs.f_namemax$get(segment);
+		return statvfs.f_namemax(segment);
 	}
 
 	@Override
 	public void setNameMax(long namemax) {
-		statvfs.f_namemax$set(segment, namemax);
+		statvfs.f_namemax(segment, namemax);
 	}
 
 }
diff --git a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/TimeSpecImpl.java b/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/TimeSpecImpl.java
index b0e03d74..38cf85ef 100644
--- a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/TimeSpecImpl.java
+++ b/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/TimeSpecImpl.java
@@ -11,26 +11,26 @@ record TimeSpecImpl(MemorySegment segment) implements TimeSpec {
 
 	@Override
 	public boolean isUtimeOmit() {
-		var nanos = timespec.tv_nsec$get(segment);
+		var nanos = timespec.tv_nsec(segment);
 		return stat_h.UTIME_OMIT() == nanos;
 	}
 
 	@Override
 	public boolean isUtimeNow() {
-		var nanos = timespec.tv_nsec$get(segment);
+		var nanos = timespec.tv_nsec(segment);
 		return stat_h.UTIME_NOW() == nanos;
 	}
 
 	@Override
 	public void set(Instant newValue) {
-		timespec.tv_sec$set(segment, newValue.getEpochSecond());
-		timespec.tv_nsec$set(segment, newValue.getNano());
+		timespec.tv_sec(segment, newValue.getEpochSecond());
+		timespec.tv_nsec(segment, newValue.getNano());
 	}
 
 	@Override
 	public Instant get() {
-		var seconds = timespec.tv_sec$get(segment);
-		var nanos = timespec.tv_nsec$get(segment);
+		var seconds = timespec.tv_sec(segment);
+		var nanos = timespec.tv_nsec(segment);
 		return Instant.ofEpochSecond(seconds, nanos);
 	}
 
diff --git a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/errno/RuntimeHelper.java b/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/errno/RuntimeHelper.java
deleted file mode 100644
index 2eec54fb..00000000
--- a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/errno/RuntimeHelper.java
+++ /dev/null
@@ -1,245 +0,0 @@
-package org.cryptomator.jfuse.mac.extr.errno;
-// Generated by jextract
-
-import java.lang.foreign.Linker;
-import java.lang.foreign.FunctionDescriptor;
-import java.lang.foreign.GroupLayout;
-import java.lang.foreign.SymbolLookup;
-import java.lang.foreign.MemoryLayout;
-import java.lang.foreign.MemorySegment;
-import java.lang.foreign.Arena;
-import java.lang.foreign.SegmentAllocator;
-import java.lang.foreign.ValueLayout;
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.MethodHandles;
-import java.lang.invoke.MethodType;
-import java.io.File;
-import java.nio.file.Path;
-import java.nio.charset.StandardCharsets;
-import java.util.Arrays;
-import java.util.Optional;
-import java.util.stream.Stream;
-
-import java.lang.foreign.AddressLayout;
-import java.lang.foreign.MemoryLayout;
-
-import static java.lang.foreign.Linker.*;
-import static java.lang.foreign.ValueLayout.*;
-
-final class RuntimeHelper {
-
-    private static final Linker LINKER = Linker.nativeLinker();
-    private static final ClassLoader LOADER = RuntimeHelper.class.getClassLoader();
-    private static final MethodHandles.Lookup MH_LOOKUP = MethodHandles.lookup();
-    private static final SymbolLookup SYMBOL_LOOKUP;
-    private static final SegmentAllocator THROWING_ALLOCATOR = (x, y) -> { throw new AssertionError("should not reach here"); };
-    static final AddressLayout POINTER = ValueLayout.ADDRESS.withTargetLayout(MemoryLayout.sequenceLayout(JAVA_BYTE));
-
-    final static SegmentAllocator CONSTANT_ALLOCATOR =
-            (size, align) -> Arena.ofAuto().allocate(size, align);
-
-    static {
-        
-        SymbolLookup loaderLookup = SymbolLookup.loaderLookup();
-        SYMBOL_LOOKUP = name -> loaderLookup.find(name).or(() -> LINKER.defaultLookup().find(name));
-    }
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private RuntimeHelper() {}
-
-    static <T> T requireNonNull(T obj, String symbolName) {
-        if (obj == null) {
-            throw new UnsatisfiedLinkError("unresolved symbol: " + symbolName);
-        }
-        return obj;
-    }
-
-    static MemorySegment lookupGlobalVariable(String name, MemoryLayout layout) {
-        return SYMBOL_LOOKUP.find(name)
-                .map(s -> s.reinterpret(layout.byteSize()))
-                .orElse(null);
-    }
-
-    static MethodHandle downcallHandle(String name, FunctionDescriptor fdesc) {
-        return SYMBOL_LOOKUP.find(name).
-                map(addr -> LINKER.downcallHandle(addr, fdesc)).
-                orElse(null);
-    }
-
-    static MethodHandle downcallHandle(FunctionDescriptor fdesc) {
-        return LINKER.downcallHandle(fdesc);
-    }
-
-    static MethodHandle downcallHandleVariadic(String name, FunctionDescriptor fdesc) {
-        return SYMBOL_LOOKUP.find(name).
-                map(addr -> VarargsInvoker.make(addr, fdesc)).
-                orElse(null);
-    }
-
-    static MethodHandle upcallHandle(Class<?> fi, String name, FunctionDescriptor fdesc) {
-        try {
-            return MH_LOOKUP.findVirtual(fi, name, fdesc.toMethodType());
-        } catch (Throwable ex) {
-            throw new AssertionError(ex);
-        }
-    }
-
-    static <Z> MemorySegment upcallStub(MethodHandle fiHandle, Z z, FunctionDescriptor fdesc, Arena scope) {
-        try {
-            fiHandle = fiHandle.bindTo(z);
-            return LINKER.upcallStub(fiHandle, fdesc, scope);
-        } catch (Throwable ex) {
-            throw new AssertionError(ex);
-        }
-    }
-
-    static MemorySegment asArray(MemorySegment addr, MemoryLayout layout, int numElements, Arena arena) {
-         return addr.reinterpret(numElements * layout.byteSize(), arena, null);
-    }
-
-    // Internals only below this point
-
-    private static final class VarargsInvoker {
-        private static final MethodHandle INVOKE_MH;
-        private final MemorySegment symbol;
-        private final FunctionDescriptor function;
-
-        private VarargsInvoker(MemorySegment symbol, FunctionDescriptor function) {
-            this.symbol = symbol;
-            this.function = function;
-        }
-
-        static {
-            try {
-                INVOKE_MH = MethodHandles.lookup().findVirtual(VarargsInvoker.class, "invoke", MethodType.methodType(Object.class, SegmentAllocator.class, Object[].class));
-            } catch (ReflectiveOperationException e) {
-                throw new RuntimeException(e);
-            }
-        }
-
-        static MethodHandle make(MemorySegment symbol, FunctionDescriptor function) {
-            VarargsInvoker invoker = new VarargsInvoker(symbol, function);
-            MethodHandle handle = INVOKE_MH.bindTo(invoker).asCollector(Object[].class, function.argumentLayouts().size() + 1);
-            MethodType mtype = MethodType.methodType(function.returnLayout().isPresent() ? carrier(function.returnLayout().get(), true) : void.class);
-            for (MemoryLayout layout : function.argumentLayouts()) {
-                mtype = mtype.appendParameterTypes(carrier(layout, false));
-            }
-            mtype = mtype.appendParameterTypes(Object[].class);
-            boolean needsAllocator = function.returnLayout().isPresent() &&
-                                function.returnLayout().get() instanceof GroupLayout;
-            if (needsAllocator) {
-                mtype = mtype.insertParameterTypes(0, SegmentAllocator.class);
-            } else {
-                handle = MethodHandles.insertArguments(handle, 0, THROWING_ALLOCATOR);
-            }
-            return handle.asType(mtype);
-        }
-
-        static Class<?> carrier(MemoryLayout layout, boolean ret) {
-            if (layout instanceof ValueLayout valueLayout) {
-                return valueLayout.carrier();
-            } else if (layout instanceof GroupLayout) {
-                return MemorySegment.class;
-            } else {
-                throw new AssertionError("Cannot get here!");
-            }
-        }
-
-        private Object invoke(SegmentAllocator allocator, Object[] args) throws Throwable {
-            // one trailing Object[]
-            int nNamedArgs = function.argumentLayouts().size();
-            assert(args.length == nNamedArgs + 1);
-            // The last argument is the array of vararg collector
-            Object[] unnamedArgs = (Object[]) args[args.length - 1];
-
-            int argsCount = nNamedArgs + unnamedArgs.length;
-            Class<?>[] argTypes = new Class<?>[argsCount];
-            MemoryLayout[] argLayouts = new MemoryLayout[nNamedArgs + unnamedArgs.length];
-
-            int pos = 0;
-            for (pos = 0; pos < nNamedArgs; pos++) {
-                argLayouts[pos] = function.argumentLayouts().get(pos);
-            }
-
-            assert pos == nNamedArgs;
-            for (Object o: unnamedArgs) {
-                argLayouts[pos] = variadicLayout(normalize(o.getClass()));
-                pos++;
-            }
-            assert pos == argsCount;
-
-            FunctionDescriptor f = (function.returnLayout().isEmpty()) ?
-                    FunctionDescriptor.ofVoid(argLayouts) :
-                    FunctionDescriptor.of(function.returnLayout().get(), argLayouts);
-            MethodHandle mh = LINKER.downcallHandle(symbol, f);
-            boolean needsAllocator = function.returnLayout().isPresent() &&
-                                            function.returnLayout().get() instanceof GroupLayout;
-            if (needsAllocator) {
-                mh = mh.bindTo(allocator);
-            }
-            // flatten argument list so that it can be passed to an asSpreader MH
-            Object[] allArgs = new Object[nNamedArgs + unnamedArgs.length];
-            System.arraycopy(args, 0, allArgs, 0, nNamedArgs);
-            System.arraycopy(unnamedArgs, 0, allArgs, nNamedArgs, unnamedArgs.length);
-
-            return mh.asSpreader(Object[].class, argsCount).invoke(allArgs);
-        }
-
-        private static Class<?> unboxIfNeeded(Class<?> clazz) {
-            if (clazz == Boolean.class) {
-                return boolean.class;
-            } else if (clazz == Void.class) {
-                return void.class;
-            } else if (clazz == Byte.class) {
-                return byte.class;
-            } else if (clazz == Character.class) {
-                return char.class;
-            } else if (clazz == Short.class) {
-                return short.class;
-            } else if (clazz == Integer.class) {
-                return int.class;
-            } else if (clazz == Long.class) {
-                return long.class;
-            } else if (clazz == Float.class) {
-                return float.class;
-            } else if (clazz == Double.class) {
-                return double.class;
-            } else {
-                return clazz;
-            }
-        }
-
-        private Class<?> promote(Class<?> c) {
-            if (c == byte.class || c == char.class || c == short.class || c == int.class) {
-                return long.class;
-            } else if (c == float.class) {
-                return double.class;
-            } else {
-                return c;
-            }
-        }
-
-        private Class<?> normalize(Class<?> c) {
-            c = unboxIfNeeded(c);
-            if (c.isPrimitive()) {
-                return promote(c);
-            }
-            if (c == MemorySegment.class) {
-                return MemorySegment.class;
-            }
-            throw new IllegalArgumentException("Invalid type for ABI: " + c.getTypeName());
-        }
-
-        private MemoryLayout variadicLayout(Class<?> c) {
-            if (c == long.class) {
-                return JAVA_LONG;
-            } else if (c == double.class) {
-                return JAVA_DOUBLE;
-            } else if (c == MemorySegment.class) {
-                return ADDRESS;
-            } else {
-                throw new IllegalArgumentException("Unhandled variadic argument class: " + c);
-            }
-        }
-    }
-}
diff --git a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/errno/constants$0.java b/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/errno/constants$0.java
deleted file mode 100644
index 8aaaa0a5..00000000
--- a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/errno/constants$0.java
+++ /dev/null
@@ -1,16 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.mac.extr.errno;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$0 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$0() {}
-}
-
-
diff --git a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/errno/errno_h.java b/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/errno/errno_h.java
index 6a7ad89d..cdbc25ad 100644
--- a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/errno/errno_h.java
+++ b/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/errno/errno_h.java
@@ -2,173 +2,242 @@
 
 package org.cryptomator.jfuse.mac.extr.errno;
 
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
+import java.lang.invoke.*;
 import java.lang.foreign.*;
+import java.nio.ByteOrder;
+import java.util.*;
+import java.util.function.*;
+import java.util.stream.*;
+
 import static java.lang.foreign.ValueLayout.*;
-public class errno_h  {
+import static java.lang.foreign.MemoryLayout.PathElement.*;
+
+public class errno_h {
+
+    errno_h() {
+        // Should not be called directly
+    }
+
+    static final Arena LIBRARY_ARENA = Arena.ofAuto();
+    static final boolean TRACE_DOWNCALLS = Boolean.getBoolean("jextract.trace.downcalls");
+
+    static void traceDowncall(String name, Object... args) {
+         String traceArgs = Arrays.stream(args)
+                       .map(Object::toString)
+                       .collect(Collectors.joining(", "));
+         System.out.printf("%s(%s)\n", name, traceArgs);
+    }
 
-    public static final OfByte C_CHAR = JAVA_BYTE;
-    public static final OfShort C_SHORT = JAVA_SHORT;
-    public static final OfInt C_INT = JAVA_INT;
-    public static final OfLong C_LONG = JAVA_LONG;
-    public static final OfLong C_LONG_LONG = JAVA_LONG;
-    public static final OfFloat C_FLOAT = JAVA_FLOAT;
-    public static final OfDouble C_DOUBLE = JAVA_DOUBLE;
-    public static final AddressLayout C_POINTER = RuntimeHelper.POINTER;
-    /**
-     * {@snippet :
+    static MemorySegment findOrThrow(String symbol) {
+        return SYMBOL_LOOKUP.find(symbol)
+            .orElseThrow(() -> new UnsatisfiedLinkError("unresolved symbol: " + symbol));
+    }
+
+    static MethodHandle upcallHandle(Class<?> fi, String name, FunctionDescriptor fdesc) {
+        try {
+            return MethodHandles.lookup().findVirtual(fi, name, fdesc.toMethodType());
+        } catch (ReflectiveOperationException ex) {
+            throw new AssertionError(ex);
+        }
+    }
+
+    static MemoryLayout align(MemoryLayout layout, long align) {
+        return switch (layout) {
+            case PaddingLayout p -> p;
+            case ValueLayout v -> v.withByteAlignment(align);
+            case GroupLayout g -> {
+                MemoryLayout[] alignedMembers = g.memberLayouts().stream()
+                        .map(m -> align(m, align)).toArray(MemoryLayout[]::new);
+                yield g instanceof StructLayout ?
+                        MemoryLayout.structLayout(alignedMembers) : MemoryLayout.unionLayout(alignedMembers);
+            }
+            case SequenceLayout s -> MemoryLayout.sequenceLayout(s.elementCount(), align(s.elementLayout(), align));
+        };
+    }
+
+    static final SymbolLookup SYMBOL_LOOKUP = SymbolLookup.loaderLookup()
+            .or(Linker.nativeLinker().defaultLookup());
+
+    public static final ValueLayout.OfBoolean C_BOOL = ValueLayout.JAVA_BOOLEAN;
+    public static final ValueLayout.OfByte C_CHAR = ValueLayout.JAVA_BYTE;
+    public static final ValueLayout.OfShort C_SHORT = ValueLayout.JAVA_SHORT;
+    public static final ValueLayout.OfInt C_INT = ValueLayout.JAVA_INT;
+    public static final ValueLayout.OfLong C_LONG_LONG = ValueLayout.JAVA_LONG;
+    public static final ValueLayout.OfFloat C_FLOAT = ValueLayout.JAVA_FLOAT;
+    public static final ValueLayout.OfDouble C_DOUBLE = ValueLayout.JAVA_DOUBLE;
+    public static final AddressLayout C_POINTER = ValueLayout.ADDRESS
+            .withTargetLayout(MemoryLayout.sequenceLayout(java.lang.Long.MAX_VALUE, JAVA_BYTE));
+    public static final ValueLayout.OfLong C_LONG = ValueLayout.JAVA_LONG;
+    private static final int ENOENT = (int)2L;
+    /**
+     * {@snippet lang=c :
      * #define ENOENT 2
      * }
      */
     public static int ENOENT() {
-        return (int)2L;
+        return ENOENT;
     }
+    private static final int EIO = (int)5L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define EIO 5
      * }
      */
     public static int EIO() {
-        return (int)5L;
+        return EIO;
     }
+    private static final int E2BIG = (int)7L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define E2BIG 7
      * }
      */
     public static int E2BIG() {
-        return (int)7L;
+        return E2BIG;
     }
+    private static final int EBADF = (int)9L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define EBADF 9
      * }
      */
     public static int EBADF() {
-        return (int)9L;
+        return EBADF;
     }
+    private static final int ENOMEM = (int)12L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define ENOMEM 12
      * }
      */
     public static int ENOMEM() {
-        return (int)12L;
+        return ENOMEM;
     }
+    private static final int EACCES = (int)13L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define EACCES 13
      * }
      */
     public static int EACCES() {
-        return (int)13L;
+        return EACCES;
     }
+    private static final int EEXIST = (int)17L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define EEXIST 17
      * }
      */
     public static int EEXIST() {
-        return (int)17L;
+        return EEXIST;
     }
+    private static final int ENOTDIR = (int)20L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define ENOTDIR 20
      * }
      */
     public static int ENOTDIR() {
-        return (int)20L;
+        return ENOTDIR;
     }
+    private static final int EISDIR = (int)21L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define EISDIR 21
      * }
      */
     public static int EISDIR() {
-        return (int)21L;
+        return EISDIR;
     }
+    private static final int EINVAL = (int)22L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define EINVAL 22
      * }
      */
     public static int EINVAL() {
-        return (int)22L;
+        return EINVAL;
     }
+    private static final int EROFS = (int)30L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define EROFS 30
      * }
      */
     public static int EROFS() {
-        return (int)30L;
+        return EROFS;
     }
+    private static final int ERANGE = (int)34L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define ERANGE 34
      * }
      */
     public static int ERANGE() {
-        return (int)34L;
+        return ERANGE;
     }
+    private static final int ENOTSUP = (int)45L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define ENOTSUP 45
      * }
      */
     public static int ENOTSUP() {
-        return (int)45L;
+        return ENOTSUP;
     }
+    private static final int ENAMETOOLONG = (int)63L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define ENAMETOOLONG 63
      * }
      */
     public static int ENAMETOOLONG() {
-        return (int)63L;
+        return ENAMETOOLONG;
     }
+    private static final int ENOTEMPTY = (int)66L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define ENOTEMPTY 66
      * }
      */
     public static int ENOTEMPTY() {
-        return (int)66L;
+        return ENOTEMPTY;
     }
+    private static final int ENOLCK = (int)77L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define ENOLCK 77
      * }
      */
     public static int ENOLCK() {
-        return (int)77L;
+        return ENOLCK;
     }
+    private static final int ENOSYS = (int)78L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define ENOSYS 78
      * }
      */
     public static int ENOSYS() {
-        return (int)78L;
+        return ENOSYS;
     }
+    private static final int ENOATTR = (int)93L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define ENOATTR 93
      * }
      */
     public static int ENOATTR() {
-        return (int)93L;
+        return ENOATTR;
     }
+    private static final int ENODATA = (int)96L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define ENODATA 96
      * }
      */
     public static int ENODATA() {
-        return (int)96L;
+        return ENODATA;
     }
 }
 
-
diff --git a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fcntl/RuntimeHelper.java b/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fcntl/RuntimeHelper.java
deleted file mode 100644
index 8a8de728..00000000
--- a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fcntl/RuntimeHelper.java
+++ /dev/null
@@ -1,245 +0,0 @@
-package org.cryptomator.jfuse.mac.extr.fcntl;
-// Generated by jextract
-
-import java.lang.foreign.Linker;
-import java.lang.foreign.FunctionDescriptor;
-import java.lang.foreign.GroupLayout;
-import java.lang.foreign.SymbolLookup;
-import java.lang.foreign.MemoryLayout;
-import java.lang.foreign.MemorySegment;
-import java.lang.foreign.Arena;
-import java.lang.foreign.SegmentAllocator;
-import java.lang.foreign.ValueLayout;
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.MethodHandles;
-import java.lang.invoke.MethodType;
-import java.io.File;
-import java.nio.file.Path;
-import java.nio.charset.StandardCharsets;
-import java.util.Arrays;
-import java.util.Optional;
-import java.util.stream.Stream;
-
-import java.lang.foreign.AddressLayout;
-import java.lang.foreign.MemoryLayout;
-
-import static java.lang.foreign.Linker.*;
-import static java.lang.foreign.ValueLayout.*;
-
-final class RuntimeHelper {
-
-    private static final Linker LINKER = Linker.nativeLinker();
-    private static final ClassLoader LOADER = RuntimeHelper.class.getClassLoader();
-    private static final MethodHandles.Lookup MH_LOOKUP = MethodHandles.lookup();
-    private static final SymbolLookup SYMBOL_LOOKUP;
-    private static final SegmentAllocator THROWING_ALLOCATOR = (x, y) -> { throw new AssertionError("should not reach here"); };
-    static final AddressLayout POINTER = ValueLayout.ADDRESS.withTargetLayout(MemoryLayout.sequenceLayout(JAVA_BYTE));
-
-    final static SegmentAllocator CONSTANT_ALLOCATOR =
-            (size, align) -> Arena.ofAuto().allocate(size, align);
-
-    static {
-        
-        SymbolLookup loaderLookup = SymbolLookup.loaderLookup();
-        SYMBOL_LOOKUP = name -> loaderLookup.find(name).or(() -> LINKER.defaultLookup().find(name));
-    }
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private RuntimeHelper() {}
-
-    static <T> T requireNonNull(T obj, String symbolName) {
-        if (obj == null) {
-            throw new UnsatisfiedLinkError("unresolved symbol: " + symbolName);
-        }
-        return obj;
-    }
-
-    static MemorySegment lookupGlobalVariable(String name, MemoryLayout layout) {
-        return SYMBOL_LOOKUP.find(name)
-                .map(s -> s.reinterpret(layout.byteSize()))
-                .orElse(null);
-    }
-
-    static MethodHandle downcallHandle(String name, FunctionDescriptor fdesc) {
-        return SYMBOL_LOOKUP.find(name).
-                map(addr -> LINKER.downcallHandle(addr, fdesc)).
-                orElse(null);
-    }
-
-    static MethodHandle downcallHandle(FunctionDescriptor fdesc) {
-        return LINKER.downcallHandle(fdesc);
-    }
-
-    static MethodHandle downcallHandleVariadic(String name, FunctionDescriptor fdesc) {
-        return SYMBOL_LOOKUP.find(name).
-                map(addr -> VarargsInvoker.make(addr, fdesc)).
-                orElse(null);
-    }
-
-    static MethodHandle upcallHandle(Class<?> fi, String name, FunctionDescriptor fdesc) {
-        try {
-            return MH_LOOKUP.findVirtual(fi, name, fdesc.toMethodType());
-        } catch (Throwable ex) {
-            throw new AssertionError(ex);
-        }
-    }
-
-    static <Z> MemorySegment upcallStub(MethodHandle fiHandle, Z z, FunctionDescriptor fdesc, Arena scope) {
-        try {
-            fiHandle = fiHandle.bindTo(z);
-            return LINKER.upcallStub(fiHandle, fdesc, scope);
-        } catch (Throwable ex) {
-            throw new AssertionError(ex);
-        }
-    }
-
-    static MemorySegment asArray(MemorySegment addr, MemoryLayout layout, int numElements, Arena arena) {
-         return addr.reinterpret(numElements * layout.byteSize(), arena, null);
-    }
-
-    // Internals only below this point
-
-    private static final class VarargsInvoker {
-        private static final MethodHandle INVOKE_MH;
-        private final MemorySegment symbol;
-        private final FunctionDescriptor function;
-
-        private VarargsInvoker(MemorySegment symbol, FunctionDescriptor function) {
-            this.symbol = symbol;
-            this.function = function;
-        }
-
-        static {
-            try {
-                INVOKE_MH = MethodHandles.lookup().findVirtual(VarargsInvoker.class, "invoke", MethodType.methodType(Object.class, SegmentAllocator.class, Object[].class));
-            } catch (ReflectiveOperationException e) {
-                throw new RuntimeException(e);
-            }
-        }
-
-        static MethodHandle make(MemorySegment symbol, FunctionDescriptor function) {
-            VarargsInvoker invoker = new VarargsInvoker(symbol, function);
-            MethodHandle handle = INVOKE_MH.bindTo(invoker).asCollector(Object[].class, function.argumentLayouts().size() + 1);
-            MethodType mtype = MethodType.methodType(function.returnLayout().isPresent() ? carrier(function.returnLayout().get(), true) : void.class);
-            for (MemoryLayout layout : function.argumentLayouts()) {
-                mtype = mtype.appendParameterTypes(carrier(layout, false));
-            }
-            mtype = mtype.appendParameterTypes(Object[].class);
-            boolean needsAllocator = function.returnLayout().isPresent() &&
-                                function.returnLayout().get() instanceof GroupLayout;
-            if (needsAllocator) {
-                mtype = mtype.insertParameterTypes(0, SegmentAllocator.class);
-            } else {
-                handle = MethodHandles.insertArguments(handle, 0, THROWING_ALLOCATOR);
-            }
-            return handle.asType(mtype);
-        }
-
-        static Class<?> carrier(MemoryLayout layout, boolean ret) {
-            if (layout instanceof ValueLayout valueLayout) {
-                return valueLayout.carrier();
-            } else if (layout instanceof GroupLayout) {
-                return MemorySegment.class;
-            } else {
-                throw new AssertionError("Cannot get here!");
-            }
-        }
-
-        private Object invoke(SegmentAllocator allocator, Object[] args) throws Throwable {
-            // one trailing Object[]
-            int nNamedArgs = function.argumentLayouts().size();
-            assert(args.length == nNamedArgs + 1);
-            // The last argument is the array of vararg collector
-            Object[] unnamedArgs = (Object[]) args[args.length - 1];
-
-            int argsCount = nNamedArgs + unnamedArgs.length;
-            Class<?>[] argTypes = new Class<?>[argsCount];
-            MemoryLayout[] argLayouts = new MemoryLayout[nNamedArgs + unnamedArgs.length];
-
-            int pos = 0;
-            for (pos = 0; pos < nNamedArgs; pos++) {
-                argLayouts[pos] = function.argumentLayouts().get(pos);
-            }
-
-            assert pos == nNamedArgs;
-            for (Object o: unnamedArgs) {
-                argLayouts[pos] = variadicLayout(normalize(o.getClass()));
-                pos++;
-            }
-            assert pos == argsCount;
-
-            FunctionDescriptor f = (function.returnLayout().isEmpty()) ?
-                    FunctionDescriptor.ofVoid(argLayouts) :
-                    FunctionDescriptor.of(function.returnLayout().get(), argLayouts);
-            MethodHandle mh = LINKER.downcallHandle(symbol, f);
-            boolean needsAllocator = function.returnLayout().isPresent() &&
-                                            function.returnLayout().get() instanceof GroupLayout;
-            if (needsAllocator) {
-                mh = mh.bindTo(allocator);
-            }
-            // flatten argument list so that it can be passed to an asSpreader MH
-            Object[] allArgs = new Object[nNamedArgs + unnamedArgs.length];
-            System.arraycopy(args, 0, allArgs, 0, nNamedArgs);
-            System.arraycopy(unnamedArgs, 0, allArgs, nNamedArgs, unnamedArgs.length);
-
-            return mh.asSpreader(Object[].class, argsCount).invoke(allArgs);
-        }
-
-        private static Class<?> unboxIfNeeded(Class<?> clazz) {
-            if (clazz == Boolean.class) {
-                return boolean.class;
-            } else if (clazz == Void.class) {
-                return void.class;
-            } else if (clazz == Byte.class) {
-                return byte.class;
-            } else if (clazz == Character.class) {
-                return char.class;
-            } else if (clazz == Short.class) {
-                return short.class;
-            } else if (clazz == Integer.class) {
-                return int.class;
-            } else if (clazz == Long.class) {
-                return long.class;
-            } else if (clazz == Float.class) {
-                return float.class;
-            } else if (clazz == Double.class) {
-                return double.class;
-            } else {
-                return clazz;
-            }
-        }
-
-        private Class<?> promote(Class<?> c) {
-            if (c == byte.class || c == char.class || c == short.class || c == int.class) {
-                return long.class;
-            } else if (c == float.class) {
-                return double.class;
-            } else {
-                return c;
-            }
-        }
-
-        private Class<?> normalize(Class<?> c) {
-            c = unboxIfNeeded(c);
-            if (c.isPrimitive()) {
-                return promote(c);
-            }
-            if (c == MemorySegment.class) {
-                return MemorySegment.class;
-            }
-            throw new IllegalArgumentException("Invalid type for ABI: " + c.getTypeName());
-        }
-
-        private MemoryLayout variadicLayout(Class<?> c) {
-            if (c == long.class) {
-                return JAVA_LONG;
-            } else if (c == double.class) {
-                return JAVA_DOUBLE;
-            } else if (c == MemorySegment.class) {
-                return ADDRESS;
-            } else {
-                throw new IllegalArgumentException("Unhandled variadic argument class: " + c);
-            }
-        }
-    }
-}
diff --git a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fcntl/constants$0.java b/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fcntl/constants$0.java
deleted file mode 100644
index 9948108a..00000000
--- a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fcntl/constants$0.java
+++ /dev/null
@@ -1,16 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.mac.extr.fcntl;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$0 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$0() {}
-}
-
-
diff --git a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fcntl/fcntl_h.java b/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fcntl/fcntl_h.java
index 30498529..eb93bc98 100644
--- a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fcntl/fcntl_h.java
+++ b/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fcntl/fcntl_h.java
@@ -2,93 +2,152 @@
 
 package org.cryptomator.jfuse.mac.extr.fcntl;
 
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
+import java.lang.invoke.*;
 import java.lang.foreign.*;
+import java.nio.ByteOrder;
+import java.util.*;
+import java.util.function.*;
+import java.util.stream.*;
+
 import static java.lang.foreign.ValueLayout.*;
-public class fcntl_h  {
+import static java.lang.foreign.MemoryLayout.PathElement.*;
+
+public class fcntl_h {
+
+    fcntl_h() {
+        // Should not be called directly
+    }
+
+    static final Arena LIBRARY_ARENA = Arena.ofAuto();
+    static final boolean TRACE_DOWNCALLS = Boolean.getBoolean("jextract.trace.downcalls");
+
+    static void traceDowncall(String name, Object... args) {
+         String traceArgs = Arrays.stream(args)
+                       .map(Object::toString)
+                       .collect(Collectors.joining(", "));
+         System.out.printf("%s(%s)\n", name, traceArgs);
+    }
 
-    public static final OfByte C_CHAR = JAVA_BYTE;
-    public static final OfShort C_SHORT = JAVA_SHORT;
-    public static final OfInt C_INT = JAVA_INT;
-    public static final OfLong C_LONG = JAVA_LONG;
-    public static final OfLong C_LONG_LONG = JAVA_LONG;
-    public static final OfFloat C_FLOAT = JAVA_FLOAT;
-    public static final OfDouble C_DOUBLE = JAVA_DOUBLE;
-    public static final AddressLayout C_POINTER = RuntimeHelper.POINTER;
+    static MemorySegment findOrThrow(String symbol) {
+        return SYMBOL_LOOKUP.find(symbol)
+            .orElseThrow(() -> new UnsatisfiedLinkError("unresolved symbol: " + symbol));
+    }
+
+    static MethodHandle upcallHandle(Class<?> fi, String name, FunctionDescriptor fdesc) {
+        try {
+            return MethodHandles.lookup().findVirtual(fi, name, fdesc.toMethodType());
+        } catch (ReflectiveOperationException ex) {
+            throw new AssertionError(ex);
+        }
+    }
+
+    static MemoryLayout align(MemoryLayout layout, long align) {
+        return switch (layout) {
+            case PaddingLayout p -> p;
+            case ValueLayout v -> v.withByteAlignment(align);
+            case GroupLayout g -> {
+                MemoryLayout[] alignedMembers = g.memberLayouts().stream()
+                        .map(m -> align(m, align)).toArray(MemoryLayout[]::new);
+                yield g instanceof StructLayout ?
+                        MemoryLayout.structLayout(alignedMembers) : MemoryLayout.unionLayout(alignedMembers);
+            }
+            case SequenceLayout s -> MemoryLayout.sequenceLayout(s.elementCount(), align(s.elementLayout(), align));
+        };
+    }
+
+    static final SymbolLookup SYMBOL_LOOKUP = SymbolLookup.loaderLookup()
+            .or(Linker.nativeLinker().defaultLookup());
+
+    public static final ValueLayout.OfBoolean C_BOOL = ValueLayout.JAVA_BOOLEAN;
+    public static final ValueLayout.OfByte C_CHAR = ValueLayout.JAVA_BYTE;
+    public static final ValueLayout.OfShort C_SHORT = ValueLayout.JAVA_SHORT;
+    public static final ValueLayout.OfInt C_INT = ValueLayout.JAVA_INT;
+    public static final ValueLayout.OfLong C_LONG_LONG = ValueLayout.JAVA_LONG;
+    public static final ValueLayout.OfFloat C_FLOAT = ValueLayout.JAVA_FLOAT;
+    public static final ValueLayout.OfDouble C_DOUBLE = ValueLayout.JAVA_DOUBLE;
+    public static final AddressLayout C_POINTER = ValueLayout.ADDRESS
+            .withTargetLayout(MemoryLayout.sequenceLayout(java.lang.Long.MAX_VALUE, JAVA_BYTE));
+    public static final ValueLayout.OfLong C_LONG = ValueLayout.JAVA_LONG;
+    private static final int O_RDONLY = (int)0L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define O_RDONLY 0
      * }
      */
     public static int O_RDONLY() {
-        return (int)0L;
+        return O_RDONLY;
     }
+    private static final int O_WRONLY = (int)1L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define O_WRONLY 1
      * }
      */
     public static int O_WRONLY() {
-        return (int)1L;
+        return O_WRONLY;
     }
+    private static final int O_RDWR = (int)2L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define O_RDWR 2
      * }
      */
     public static int O_RDWR() {
-        return (int)2L;
+        return O_RDWR;
     }
+    private static final int O_APPEND = (int)8L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define O_APPEND 8
      * }
      */
     public static int O_APPEND() {
-        return (int)8L;
+        return O_APPEND;
     }
+    private static final int O_SYNC = (int)128L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define O_SYNC 128
      * }
      */
     public static int O_SYNC() {
-        return (int)128L;
+        return O_SYNC;
     }
+    private static final int O_CREAT = (int)512L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define O_CREAT 512
      * }
      */
     public static int O_CREAT() {
-        return (int)512L;
+        return O_CREAT;
     }
+    private static final int O_TRUNC = (int)1024L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define O_TRUNC 1024
      * }
      */
     public static int O_TRUNC() {
-        return (int)1024L;
+        return O_TRUNC;
     }
+    private static final int O_EXCL = (int)2048L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define O_EXCL 2048
      * }
      */
     public static int O_EXCL() {
-        return (int)2048L;
+        return O_EXCL;
     }
+    private static final int O_DSYNC = (int)4194304L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define O_DSYNC 4194304
      * }
      */
     public static int O_DSYNC() {
-        return (int)4194304L;
+        return O_DSYNC;
     }
 }
 
-
diff --git a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/RuntimeHelper.java b/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/RuntimeHelper.java
deleted file mode 100644
index 7ae43fa5..00000000
--- a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/RuntimeHelper.java
+++ /dev/null
@@ -1,245 +0,0 @@
-package org.cryptomator.jfuse.mac.extr.fuse;
-// Generated by jextract
-
-import java.lang.foreign.Linker;
-import java.lang.foreign.FunctionDescriptor;
-import java.lang.foreign.GroupLayout;
-import java.lang.foreign.SymbolLookup;
-import java.lang.foreign.MemoryLayout;
-import java.lang.foreign.MemorySegment;
-import java.lang.foreign.Arena;
-import java.lang.foreign.SegmentAllocator;
-import java.lang.foreign.ValueLayout;
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.MethodHandles;
-import java.lang.invoke.MethodType;
-import java.io.File;
-import java.nio.file.Path;
-import java.nio.charset.StandardCharsets;
-import java.util.Arrays;
-import java.util.Optional;
-import java.util.stream.Stream;
-
-import java.lang.foreign.AddressLayout;
-import java.lang.foreign.MemoryLayout;
-
-import static java.lang.foreign.Linker.*;
-import static java.lang.foreign.ValueLayout.*;
-
-final class RuntimeHelper {
-
-    private static final Linker LINKER = Linker.nativeLinker();
-    private static final ClassLoader LOADER = RuntimeHelper.class.getClassLoader();
-    private static final MethodHandles.Lookup MH_LOOKUP = MethodHandles.lookup();
-    private static final SymbolLookup SYMBOL_LOOKUP;
-    private static final SegmentAllocator THROWING_ALLOCATOR = (x, y) -> { throw new AssertionError("should not reach here"); };
-    static final AddressLayout POINTER = ValueLayout.ADDRESS.withTargetLayout(MemoryLayout.sequenceLayout(JAVA_BYTE));
-
-    final static SegmentAllocator CONSTANT_ALLOCATOR =
-            (size, align) -> Arena.ofAuto().allocate(size, align);
-
-    static {
-        
-        SymbolLookup loaderLookup = SymbolLookup.loaderLookup();
-        SYMBOL_LOOKUP = name -> loaderLookup.find(name).or(() -> LINKER.defaultLookup().find(name));
-    }
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private RuntimeHelper() {}
-
-    static <T> T requireNonNull(T obj, String symbolName) {
-        if (obj == null) {
-            throw new UnsatisfiedLinkError("unresolved symbol: " + symbolName);
-        }
-        return obj;
-    }
-
-    static MemorySegment lookupGlobalVariable(String name, MemoryLayout layout) {
-        return SYMBOL_LOOKUP.find(name)
-                .map(s -> s.reinterpret(layout.byteSize()))
-                .orElse(null);
-    }
-
-    static MethodHandle downcallHandle(String name, FunctionDescriptor fdesc) {
-        return SYMBOL_LOOKUP.find(name).
-                map(addr -> LINKER.downcallHandle(addr, fdesc)).
-                orElse(null);
-    }
-
-    static MethodHandle downcallHandle(FunctionDescriptor fdesc) {
-        return LINKER.downcallHandle(fdesc);
-    }
-
-    static MethodHandle downcallHandleVariadic(String name, FunctionDescriptor fdesc) {
-        return SYMBOL_LOOKUP.find(name).
-                map(addr -> VarargsInvoker.make(addr, fdesc)).
-                orElse(null);
-    }
-
-    static MethodHandle upcallHandle(Class<?> fi, String name, FunctionDescriptor fdesc) {
-        try {
-            return MH_LOOKUP.findVirtual(fi, name, fdesc.toMethodType());
-        } catch (Throwable ex) {
-            throw new AssertionError(ex);
-        }
-    }
-
-    static <Z> MemorySegment upcallStub(MethodHandle fiHandle, Z z, FunctionDescriptor fdesc, Arena scope) {
-        try {
-            fiHandle = fiHandle.bindTo(z);
-            return LINKER.upcallStub(fiHandle, fdesc, scope);
-        } catch (Throwable ex) {
-            throw new AssertionError(ex);
-        }
-    }
-
-    static MemorySegment asArray(MemorySegment addr, MemoryLayout layout, int numElements, Arena arena) {
-         return addr.reinterpret(numElements * layout.byteSize(), arena, null);
-    }
-
-    // Internals only below this point
-
-    private static final class VarargsInvoker {
-        private static final MethodHandle INVOKE_MH;
-        private final MemorySegment symbol;
-        private final FunctionDescriptor function;
-
-        private VarargsInvoker(MemorySegment symbol, FunctionDescriptor function) {
-            this.symbol = symbol;
-            this.function = function;
-        }
-
-        static {
-            try {
-                INVOKE_MH = MethodHandles.lookup().findVirtual(VarargsInvoker.class, "invoke", MethodType.methodType(Object.class, SegmentAllocator.class, Object[].class));
-            } catch (ReflectiveOperationException e) {
-                throw new RuntimeException(e);
-            }
-        }
-
-        static MethodHandle make(MemorySegment symbol, FunctionDescriptor function) {
-            VarargsInvoker invoker = new VarargsInvoker(symbol, function);
-            MethodHandle handle = INVOKE_MH.bindTo(invoker).asCollector(Object[].class, function.argumentLayouts().size() + 1);
-            MethodType mtype = MethodType.methodType(function.returnLayout().isPresent() ? carrier(function.returnLayout().get(), true) : void.class);
-            for (MemoryLayout layout : function.argumentLayouts()) {
-                mtype = mtype.appendParameterTypes(carrier(layout, false));
-            }
-            mtype = mtype.appendParameterTypes(Object[].class);
-            boolean needsAllocator = function.returnLayout().isPresent() &&
-                                function.returnLayout().get() instanceof GroupLayout;
-            if (needsAllocator) {
-                mtype = mtype.insertParameterTypes(0, SegmentAllocator.class);
-            } else {
-                handle = MethodHandles.insertArguments(handle, 0, THROWING_ALLOCATOR);
-            }
-            return handle.asType(mtype);
-        }
-
-        static Class<?> carrier(MemoryLayout layout, boolean ret) {
-            if (layout instanceof ValueLayout valueLayout) {
-                return valueLayout.carrier();
-            } else if (layout instanceof GroupLayout) {
-                return MemorySegment.class;
-            } else {
-                throw new AssertionError("Cannot get here!");
-            }
-        }
-
-        private Object invoke(SegmentAllocator allocator, Object[] args) throws Throwable {
-            // one trailing Object[]
-            int nNamedArgs = function.argumentLayouts().size();
-            assert(args.length == nNamedArgs + 1);
-            // The last argument is the array of vararg collector
-            Object[] unnamedArgs = (Object[]) args[args.length - 1];
-
-            int argsCount = nNamedArgs + unnamedArgs.length;
-            Class<?>[] argTypes = new Class<?>[argsCount];
-            MemoryLayout[] argLayouts = new MemoryLayout[nNamedArgs + unnamedArgs.length];
-
-            int pos = 0;
-            for (pos = 0; pos < nNamedArgs; pos++) {
-                argLayouts[pos] = function.argumentLayouts().get(pos);
-            }
-
-            assert pos == nNamedArgs;
-            for (Object o: unnamedArgs) {
-                argLayouts[pos] = variadicLayout(normalize(o.getClass()));
-                pos++;
-            }
-            assert pos == argsCount;
-
-            FunctionDescriptor f = (function.returnLayout().isEmpty()) ?
-                    FunctionDescriptor.ofVoid(argLayouts) :
-                    FunctionDescriptor.of(function.returnLayout().get(), argLayouts);
-            MethodHandle mh = LINKER.downcallHandle(symbol, f);
-            boolean needsAllocator = function.returnLayout().isPresent() &&
-                                            function.returnLayout().get() instanceof GroupLayout;
-            if (needsAllocator) {
-                mh = mh.bindTo(allocator);
-            }
-            // flatten argument list so that it can be passed to an asSpreader MH
-            Object[] allArgs = new Object[nNamedArgs + unnamedArgs.length];
-            System.arraycopy(args, 0, allArgs, 0, nNamedArgs);
-            System.arraycopy(unnamedArgs, 0, allArgs, nNamedArgs, unnamedArgs.length);
-
-            return mh.asSpreader(Object[].class, argsCount).invoke(allArgs);
-        }
-
-        private static Class<?> unboxIfNeeded(Class<?> clazz) {
-            if (clazz == Boolean.class) {
-                return boolean.class;
-            } else if (clazz == Void.class) {
-                return void.class;
-            } else if (clazz == Byte.class) {
-                return byte.class;
-            } else if (clazz == Character.class) {
-                return char.class;
-            } else if (clazz == Short.class) {
-                return short.class;
-            } else if (clazz == Integer.class) {
-                return int.class;
-            } else if (clazz == Long.class) {
-                return long.class;
-            } else if (clazz == Float.class) {
-                return float.class;
-            } else if (clazz == Double.class) {
-                return double.class;
-            } else {
-                return clazz;
-            }
-        }
-
-        private Class<?> promote(Class<?> c) {
-            if (c == byte.class || c == char.class || c == short.class || c == int.class) {
-                return long.class;
-            } else if (c == float.class) {
-                return double.class;
-            } else {
-                return c;
-            }
-        }
-
-        private Class<?> normalize(Class<?> c) {
-            c = unboxIfNeeded(c);
-            if (c.isPrimitive()) {
-                return promote(c);
-            }
-            if (c == MemorySegment.class) {
-                return MemorySegment.class;
-            }
-            throw new IllegalArgumentException("Invalid type for ABI: " + c.getTypeName());
-        }
-
-        private MemoryLayout variadicLayout(Class<?> c) {
-            if (c == long.class) {
-                return JAVA_LONG;
-            } else if (c == double.class) {
-                return JAVA_DOUBLE;
-            } else if (c == MemorySegment.class) {
-                return ADDRESS;
-            } else {
-                throw new IllegalArgumentException("Unhandled variadic argument class: " + c);
-            }
-        }
-    }
-}
diff --git a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/constants$0.java b/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/constants$0.java
deleted file mode 100644
index 77c67a8c..00000000
--- a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/constants$0.java
+++ /dev/null
@@ -1,36 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.mac.extr.fuse;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$0 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$0() {}
-    static final StructLayout const$0 = MemoryLayout.structLayout(
-        JAVA_INT.withName("argc"),
-        MemoryLayout.paddingLayout(4),
-        RuntimeHelper.POINTER.withName("argv"),
-        JAVA_INT.withName("allocated"),
-        MemoryLayout.paddingLayout(4)
-    ).withName("fuse_args");
-    static final VarHandle const$1 = constants$0.const$0.varHandle(MemoryLayout.PathElement.groupElement("argc"));
-    static final VarHandle const$2 = constants$0.const$0.varHandle(MemoryLayout.PathElement.groupElement("argv"));
-    static final VarHandle const$3 = constants$0.const$0.varHandle(MemoryLayout.PathElement.groupElement("allocated"));
-    static final StructLayout const$4 = MemoryLayout.structLayout(
-        JAVA_INT.withName("flags"),
-        MemoryLayout.paddingLayout(4),
-        JAVA_LONG.withName("fh_old"),
-        JAVA_INT.withName("writepage"),
-        MemoryLayout.paddingLayout(4),
-        JAVA_LONG.withName("fh"),
-        JAVA_LONG.withName("lock_owner")
-    ).withName("fuse_file_info");
-    static final VarHandle const$5 = constants$0.const$4.varHandle(MemoryLayout.PathElement.groupElement("flags"));
-}
-
-
diff --git a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/constants$1.java b/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/constants$1.java
deleted file mode 100644
index b3ff4be3..00000000
--- a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/constants$1.java
+++ /dev/null
@@ -1,33 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.mac.extr.fuse;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$1 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$1() {}
-    static final VarHandle const$0 = constants$0.const$4.varHandle(MemoryLayout.PathElement.groupElement("fh_old"));
-    static final VarHandle const$1 = constants$0.const$4.varHandle(MemoryLayout.PathElement.groupElement("writepage"));
-    static final VarHandle const$2 = constants$0.const$4.varHandle(MemoryLayout.PathElement.groupElement("fh"));
-    static final VarHandle const$3 = constants$0.const$4.varHandle(MemoryLayout.PathElement.groupElement("lock_owner"));
-    static final StructLayout const$4 = MemoryLayout.structLayout(
-        JAVA_INT.withName("proto_major"),
-        JAVA_INT.withName("proto_minor"),
-        JAVA_INT.withName("async_read"),
-        JAVA_INT.withName("max_write"),
-        JAVA_INT.withName("max_readahead"),
-        JAVA_INT.withName("capable"),
-        JAVA_INT.withName("want"),
-        JAVA_INT.withName("max_background"),
-        JAVA_INT.withName("congestion_threshold"),
-        MemoryLayout.sequenceLayout(23, JAVA_INT).withName("reserved")
-    ).withName("fuse_conn_info");
-    static final VarHandle const$5 = constants$1.const$4.varHandle(MemoryLayout.PathElement.groupElement("proto_major"));
-}
-
-
diff --git a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/constants$10.java b/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/constants$10.java
deleted file mode 100644
index 5e63fdd9..00000000
--- a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/constants$10.java
+++ /dev/null
@@ -1,30 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.mac.extr.fuse;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$10 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$10() {}
-    static final MethodHandle const$0 = RuntimeHelper.upcallHandle(fuse_operations.getattr.class, "apply", constants$9.const$5);
-    static final MethodHandle const$1 = RuntimeHelper.downcallHandle(
-        constants$9.const$5
-    );
-    static final VarHandle const$2 = constants$9.const$4.varHandle(MemoryLayout.PathElement.groupElement("getattr"));
-    static final FunctionDescriptor const$3 = FunctionDescriptor.of(JAVA_INT,
-        RuntimeHelper.POINTER,
-        RuntimeHelper.POINTER,
-        JAVA_LONG
-    );
-    static final MethodHandle const$4 = RuntimeHelper.upcallHandle(fuse_operations.readlink.class, "apply", constants$10.const$3);
-    static final MethodHandle const$5 = RuntimeHelper.downcallHandle(
-        constants$10.const$3
-    );
-}
-
-
diff --git a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/constants$11.java b/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/constants$11.java
deleted file mode 100644
index c24cadc0..00000000
--- a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/constants$11.java
+++ /dev/null
@@ -1,32 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.mac.extr.fuse;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$11 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$11() {}
-    static final VarHandle const$0 = constants$9.const$4.varHandle(MemoryLayout.PathElement.groupElement("readlink"));
-    static final FunctionDescriptor const$1 = FunctionDescriptor.of(JAVA_INT,
-        RuntimeHelper.POINTER,
-        RuntimeHelper.POINTER,
-        RuntimeHelper.POINTER
-    );
-    static final MethodHandle const$2 = RuntimeHelper.upcallHandle(fuse_operations.getdir.class, "apply", constants$11.const$1);
-    static final MethodHandle const$3 = RuntimeHelper.downcallHandle(
-        constants$11.const$1
-    );
-    static final VarHandle const$4 = constants$9.const$4.varHandle(MemoryLayout.PathElement.groupElement("getdir"));
-    static final FunctionDescriptor const$5 = FunctionDescriptor.of(JAVA_INT,
-        RuntimeHelper.POINTER,
-        JAVA_SHORT,
-        JAVA_INT
-    );
-}
-
-
diff --git a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/constants$12.java b/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/constants$12.java
deleted file mode 100644
index b5d4e837..00000000
--- a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/constants$12.java
+++ /dev/null
@@ -1,29 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.mac.extr.fuse;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$12 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$12() {}
-    static final MethodHandle const$0 = RuntimeHelper.upcallHandle(fuse_operations.mknod.class, "apply", constants$11.const$5);
-    static final MethodHandle const$1 = RuntimeHelper.downcallHandle(
-        constants$11.const$5
-    );
-    static final VarHandle const$2 = constants$9.const$4.varHandle(MemoryLayout.PathElement.groupElement("mknod"));
-    static final FunctionDescriptor const$3 = FunctionDescriptor.of(JAVA_INT,
-        RuntimeHelper.POINTER,
-        JAVA_SHORT
-    );
-    static final MethodHandle const$4 = RuntimeHelper.upcallHandle(fuse_operations.mkdir.class, "apply", constants$12.const$3);
-    static final MethodHandle const$5 = RuntimeHelper.downcallHandle(
-        constants$12.const$3
-    );
-}
-
-
diff --git a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/constants$13.java b/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/constants$13.java
deleted file mode 100644
index 0ee2a864..00000000
--- a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/constants$13.java
+++ /dev/null
@@ -1,26 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.mac.extr.fuse;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$13 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$13() {}
-    static final VarHandle const$0 = constants$9.const$4.varHandle(MemoryLayout.PathElement.groupElement("mkdir"));
-    static final FunctionDescriptor const$1 = FunctionDescriptor.of(JAVA_INT,
-        RuntimeHelper.POINTER
-    );
-    static final MethodHandle const$2 = RuntimeHelper.upcallHandle(fuse_operations.unlink.class, "apply", constants$13.const$1);
-    static final MethodHandle const$3 = RuntimeHelper.downcallHandle(
-        constants$13.const$1
-    );
-    static final VarHandle const$4 = constants$9.const$4.varHandle(MemoryLayout.PathElement.groupElement("unlink"));
-    static final MethodHandle const$5 = RuntimeHelper.upcallHandle(fuse_operations.rmdir.class, "apply", constants$13.const$1);
-}
-
-
diff --git a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/constants$14.java b/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/constants$14.java
deleted file mode 100644
index 27f688af..00000000
--- a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/constants$14.java
+++ /dev/null
@@ -1,22 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.mac.extr.fuse;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$14 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$14() {}
-    static final VarHandle const$0 = constants$9.const$4.varHandle(MemoryLayout.PathElement.groupElement("rmdir"));
-    static final MethodHandle const$1 = RuntimeHelper.upcallHandle(fuse_operations.symlink.class, "apply", constants$9.const$5);
-    static final VarHandle const$2 = constants$9.const$4.varHandle(MemoryLayout.PathElement.groupElement("symlink"));
-    static final MethodHandle const$3 = RuntimeHelper.upcallHandle(fuse_operations.rename.class, "apply", constants$9.const$5);
-    static final VarHandle const$4 = constants$9.const$4.varHandle(MemoryLayout.PathElement.groupElement("rename"));
-    static final MethodHandle const$5 = RuntimeHelper.upcallHandle(fuse_operations.link.class, "apply", constants$9.const$5);
-}
-
-
diff --git a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/constants$15.java b/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/constants$15.java
deleted file mode 100644
index 2f782098..00000000
--- a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/constants$15.java
+++ /dev/null
@@ -1,28 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.mac.extr.fuse;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$15 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$15() {}
-    static final VarHandle const$0 = constants$9.const$4.varHandle(MemoryLayout.PathElement.groupElement("link"));
-    static final MethodHandle const$1 = RuntimeHelper.upcallHandle(fuse_operations.chmod.class, "apply", constants$12.const$3);
-    static final VarHandle const$2 = constants$9.const$4.varHandle(MemoryLayout.PathElement.groupElement("chmod"));
-    static final FunctionDescriptor const$3 = FunctionDescriptor.of(JAVA_INT,
-        RuntimeHelper.POINTER,
-        JAVA_INT,
-        JAVA_INT
-    );
-    static final MethodHandle const$4 = RuntimeHelper.upcallHandle(fuse_operations.chown.class, "apply", constants$15.const$3);
-    static final MethodHandle const$5 = RuntimeHelper.downcallHandle(
-        constants$15.const$3
-    );
-}
-
-
diff --git a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/constants$16.java b/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/constants$16.java
deleted file mode 100644
index fb649ce0..00000000
--- a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/constants$16.java
+++ /dev/null
@@ -1,27 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.mac.extr.fuse;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$16 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$16() {}
-    static final VarHandle const$0 = constants$9.const$4.varHandle(MemoryLayout.PathElement.groupElement("chown"));
-    static final FunctionDescriptor const$1 = FunctionDescriptor.of(JAVA_INT,
-        RuntimeHelper.POINTER,
-        JAVA_LONG
-    );
-    static final MethodHandle const$2 = RuntimeHelper.upcallHandle(fuse_operations.truncate.class, "apply", constants$16.const$1);
-    static final MethodHandle const$3 = RuntimeHelper.downcallHandle(
-        constants$16.const$1
-    );
-    static final VarHandle const$4 = constants$9.const$4.varHandle(MemoryLayout.PathElement.groupElement("truncate"));
-    static final MethodHandle const$5 = RuntimeHelper.upcallHandle(fuse_operations.utime.class, "apply", constants$9.const$5);
-}
-
-
diff --git a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/constants$17.java b/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/constants$17.java
deleted file mode 100644
index a4b8e806..00000000
--- a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/constants$17.java
+++ /dev/null
@@ -1,30 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.mac.extr.fuse;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$17 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$17() {}
-    static final VarHandle const$0 = constants$9.const$4.varHandle(MemoryLayout.PathElement.groupElement("utime"));
-    static final MethodHandle const$1 = RuntimeHelper.upcallHandle(fuse_operations.open.class, "apply", constants$9.const$5);
-    static final VarHandle const$2 = constants$9.const$4.varHandle(MemoryLayout.PathElement.groupElement("open"));
-    static final FunctionDescriptor const$3 = FunctionDescriptor.of(JAVA_INT,
-        RuntimeHelper.POINTER,
-        RuntimeHelper.POINTER,
-        JAVA_LONG,
-        JAVA_LONG,
-        RuntimeHelper.POINTER
-    );
-    static final MethodHandle const$4 = RuntimeHelper.upcallHandle(fuse_operations.read.class, "apply", constants$17.const$3);
-    static final MethodHandle const$5 = RuntimeHelper.downcallHandle(
-        constants$17.const$3
-    );
-}
-
-
diff --git a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/constants$18.java b/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/constants$18.java
deleted file mode 100644
index b4e353f3..00000000
--- a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/constants$18.java
+++ /dev/null
@@ -1,22 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.mac.extr.fuse;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$18 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$18() {}
-    static final VarHandle const$0 = constants$9.const$4.varHandle(MemoryLayout.PathElement.groupElement("read"));
-    static final MethodHandle const$1 = RuntimeHelper.upcallHandle(fuse_operations.write.class, "apply", constants$17.const$3);
-    static final VarHandle const$2 = constants$9.const$4.varHandle(MemoryLayout.PathElement.groupElement("write"));
-    static final MethodHandle const$3 = RuntimeHelper.upcallHandle(fuse_operations.statfs.class, "apply", constants$9.const$5);
-    static final VarHandle const$4 = constants$9.const$4.varHandle(MemoryLayout.PathElement.groupElement("statfs"));
-    static final MethodHandle const$5 = RuntimeHelper.upcallHandle(fuse_operations.flush.class, "apply", constants$9.const$5);
-}
-
-
diff --git a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/constants$19.java b/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/constants$19.java
deleted file mode 100644
index 51298c39..00000000
--- a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/constants$19.java
+++ /dev/null
@@ -1,28 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.mac.extr.fuse;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$19 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$19() {}
-    static final VarHandle const$0 = constants$9.const$4.varHandle(MemoryLayout.PathElement.groupElement("flush"));
-    static final MethodHandle const$1 = RuntimeHelper.upcallHandle(fuse_operations.release.class, "apply", constants$9.const$5);
-    static final VarHandle const$2 = constants$9.const$4.varHandle(MemoryLayout.PathElement.groupElement("release"));
-    static final FunctionDescriptor const$3 = FunctionDescriptor.of(JAVA_INT,
-        RuntimeHelper.POINTER,
-        JAVA_INT,
-        RuntimeHelper.POINTER
-    );
-    static final MethodHandle const$4 = RuntimeHelper.upcallHandle(fuse_operations.fsync.class, "apply", constants$19.const$3);
-    static final MethodHandle const$5 = RuntimeHelper.downcallHandle(
-        constants$19.const$3
-    );
-}
-
-
diff --git a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/constants$2.java b/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/constants$2.java
deleted file mode 100644
index c899ac48..00000000
--- a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/constants$2.java
+++ /dev/null
@@ -1,22 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.mac.extr.fuse;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$2 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$2() {}
-    static final VarHandle const$0 = constants$1.const$4.varHandle(MemoryLayout.PathElement.groupElement("proto_minor"));
-    static final VarHandle const$1 = constants$1.const$4.varHandle(MemoryLayout.PathElement.groupElement("async_read"));
-    static final VarHandle const$2 = constants$1.const$4.varHandle(MemoryLayout.PathElement.groupElement("max_write"));
-    static final VarHandle const$3 = constants$1.const$4.varHandle(MemoryLayout.PathElement.groupElement("max_readahead"));
-    static final VarHandle const$4 = constants$1.const$4.varHandle(MemoryLayout.PathElement.groupElement("capable"));
-    static final VarHandle const$5 = constants$1.const$4.varHandle(MemoryLayout.PathElement.groupElement("want"));
-}
-
-
diff --git a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/constants$20.java b/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/constants$20.java
deleted file mode 100644
index 75406c12..00000000
--- a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/constants$20.java
+++ /dev/null
@@ -1,30 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.mac.extr.fuse;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$20 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$20() {}
-    static final VarHandle const$0 = constants$9.const$4.varHandle(MemoryLayout.PathElement.groupElement("fsync"));
-    static final FunctionDescriptor const$1 = FunctionDescriptor.of(JAVA_INT,
-        RuntimeHelper.POINTER,
-        RuntimeHelper.POINTER,
-        RuntimeHelper.POINTER,
-        JAVA_LONG,
-        JAVA_INT
-    );
-    static final MethodHandle const$2 = RuntimeHelper.upcallHandle(fuse_operations.setxattr.class, "apply", constants$20.const$1);
-    static final MethodHandle const$3 = RuntimeHelper.downcallHandle(
-        constants$20.const$1
-    );
-    static final VarHandle const$4 = constants$9.const$4.varHandle(MemoryLayout.PathElement.groupElement("setxattr"));
-    static final MethodHandle const$5 = RuntimeHelper.upcallHandle(fuse_operations.getxattr.class, "apply", constants$9.const$1);
-}
-
-
diff --git a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/constants$21.java b/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/constants$21.java
deleted file mode 100644
index 449b9791..00000000
--- a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/constants$21.java
+++ /dev/null
@@ -1,22 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.mac.extr.fuse;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$21 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$21() {}
-    static final VarHandle const$0 = constants$9.const$4.varHandle(MemoryLayout.PathElement.groupElement("getxattr"));
-    static final MethodHandle const$1 = RuntimeHelper.upcallHandle(fuse_operations.listxattr.class, "apply", constants$10.const$3);
-    static final VarHandle const$2 = constants$9.const$4.varHandle(MemoryLayout.PathElement.groupElement("listxattr"));
-    static final MethodHandle const$3 = RuntimeHelper.upcallHandle(fuse_operations.removexattr.class, "apply", constants$9.const$5);
-    static final VarHandle const$4 = constants$9.const$4.varHandle(MemoryLayout.PathElement.groupElement("removexattr"));
-    static final MethodHandle const$5 = RuntimeHelper.upcallHandle(fuse_operations.opendir.class, "apply", constants$9.const$5);
-}
-
-
diff --git a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/constants$22.java b/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/constants$22.java
deleted file mode 100644
index 9a077192..00000000
--- a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/constants$22.java
+++ /dev/null
@@ -1,30 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.mac.extr.fuse;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$22 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$22() {}
-    static final VarHandle const$0 = constants$9.const$4.varHandle(MemoryLayout.PathElement.groupElement("opendir"));
-    static final FunctionDescriptor const$1 = FunctionDescriptor.of(JAVA_INT,
-        RuntimeHelper.POINTER,
-        RuntimeHelper.POINTER,
-        RuntimeHelper.POINTER,
-        JAVA_LONG,
-        RuntimeHelper.POINTER
-    );
-    static final MethodHandle const$2 = RuntimeHelper.upcallHandle(fuse_operations.readdir.class, "apply", constants$22.const$1);
-    static final MethodHandle const$3 = RuntimeHelper.downcallHandle(
-        constants$22.const$1
-    );
-    static final VarHandle const$4 = constants$9.const$4.varHandle(MemoryLayout.PathElement.groupElement("readdir"));
-    static final MethodHandle const$5 = RuntimeHelper.upcallHandle(fuse_operations.releasedir.class, "apply", constants$9.const$5);
-}
-
-
diff --git a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/constants$23.java b/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/constants$23.java
deleted file mode 100644
index fe6b26b0..00000000
--- a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/constants$23.java
+++ /dev/null
@@ -1,26 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.mac.extr.fuse;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$23 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$23() {}
-    static final VarHandle const$0 = constants$9.const$4.varHandle(MemoryLayout.PathElement.groupElement("releasedir"));
-    static final MethodHandle const$1 = RuntimeHelper.upcallHandle(fuse_operations.fsyncdir.class, "apply", constants$19.const$3);
-    static final VarHandle const$2 = constants$9.const$4.varHandle(MemoryLayout.PathElement.groupElement("fsyncdir"));
-    static final FunctionDescriptor const$3 = FunctionDescriptor.of(RuntimeHelper.POINTER,
-        RuntimeHelper.POINTER
-    );
-    static final MethodHandle const$4 = RuntimeHelper.upcallHandle(fuse_operations.init.class, "apply", constants$23.const$3);
-    static final MethodHandle const$5 = RuntimeHelper.downcallHandle(
-        constants$23.const$3
-    );
-}
-
-
diff --git a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/constants$24.java b/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/constants$24.java
deleted file mode 100644
index 81b7ae76..00000000
--- a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/constants$24.java
+++ /dev/null
@@ -1,29 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.mac.extr.fuse;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$24 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$24() {}
-    static final VarHandle const$0 = constants$9.const$4.varHandle(MemoryLayout.PathElement.groupElement("init"));
-    static final FunctionDescriptor const$1 = FunctionDescriptor.ofVoid(
-        RuntimeHelper.POINTER
-    );
-    static final MethodHandle const$2 = RuntimeHelper.upcallHandle(fuse_operations.destroy.class, "apply", constants$24.const$1);
-    static final MethodHandle const$3 = RuntimeHelper.downcallHandle(
-        constants$24.const$1
-    );
-    static final VarHandle const$4 = constants$9.const$4.varHandle(MemoryLayout.PathElement.groupElement("destroy"));
-    static final FunctionDescriptor const$5 = FunctionDescriptor.of(JAVA_INT,
-        RuntimeHelper.POINTER,
-        JAVA_INT
-    );
-}
-
-
diff --git a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/constants$25.java b/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/constants$25.java
deleted file mode 100644
index b98e3493..00000000
--- a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/constants$25.java
+++ /dev/null
@@ -1,30 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.mac.extr.fuse;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$25 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$25() {}
-    static final MethodHandle const$0 = RuntimeHelper.upcallHandle(fuse_operations.access.class, "apply", constants$24.const$5);
-    static final MethodHandle const$1 = RuntimeHelper.downcallHandle(
-        constants$24.const$5
-    );
-    static final VarHandle const$2 = constants$9.const$4.varHandle(MemoryLayout.PathElement.groupElement("access"));
-    static final FunctionDescriptor const$3 = FunctionDescriptor.of(JAVA_INT,
-        RuntimeHelper.POINTER,
-        JAVA_SHORT,
-        RuntimeHelper.POINTER
-    );
-    static final MethodHandle const$4 = RuntimeHelper.upcallHandle(fuse_operations.create.class, "apply", constants$25.const$3);
-    static final MethodHandle const$5 = RuntimeHelper.downcallHandle(
-        constants$25.const$3
-    );
-}
-
-
diff --git a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/constants$26.java b/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/constants$26.java
deleted file mode 100644
index daebe13a..00000000
--- a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/constants$26.java
+++ /dev/null
@@ -1,28 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.mac.extr.fuse;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$26 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$26() {}
-    static final VarHandle const$0 = constants$9.const$4.varHandle(MemoryLayout.PathElement.groupElement("create"));
-    static final FunctionDescriptor const$1 = FunctionDescriptor.of(JAVA_INT,
-        RuntimeHelper.POINTER,
-        JAVA_LONG,
-        RuntimeHelper.POINTER
-    );
-    static final MethodHandle const$2 = RuntimeHelper.upcallHandle(fuse_operations.ftruncate.class, "apply", constants$26.const$1);
-    static final MethodHandle const$3 = RuntimeHelper.downcallHandle(
-        constants$26.const$1
-    );
-    static final VarHandle const$4 = constants$9.const$4.varHandle(MemoryLayout.PathElement.groupElement("ftruncate"));
-    static final MethodHandle const$5 = RuntimeHelper.upcallHandle(fuse_operations.fgetattr.class, "apply", constants$11.const$1);
-}
-
-
diff --git a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/constants$27.java b/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/constants$27.java
deleted file mode 100644
index 83f4e9eb..00000000
--- a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/constants$27.java
+++ /dev/null
@@ -1,29 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.mac.extr.fuse;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$27 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$27() {}
-    static final VarHandle const$0 = constants$9.const$4.varHandle(MemoryLayout.PathElement.groupElement("fgetattr"));
-    static final FunctionDescriptor const$1 = FunctionDescriptor.of(JAVA_INT,
-        RuntimeHelper.POINTER,
-        RuntimeHelper.POINTER,
-        JAVA_INT,
-        RuntimeHelper.POINTER
-    );
-    static final MethodHandle const$2 = RuntimeHelper.upcallHandle(fuse_operations.lock.class, "apply", constants$27.const$1);
-    static final MethodHandle const$3 = RuntimeHelper.downcallHandle(
-        constants$27.const$1
-    );
-    static final VarHandle const$4 = constants$9.const$4.varHandle(MemoryLayout.PathElement.groupElement("lock"));
-    static final MethodHandle const$5 = RuntimeHelper.upcallHandle(fuse_operations.utimens.class, "apply", constants$9.const$5);
-}
-
-
diff --git a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/constants$28.java b/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/constants$28.java
deleted file mode 100644
index 2d23c879..00000000
--- a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/constants$28.java
+++ /dev/null
@@ -1,31 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.mac.extr.fuse;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$28 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$28() {}
-    static final VarHandle const$0 = constants$9.const$4.varHandle(MemoryLayout.PathElement.groupElement("utimens"));
-    static final MethodHandle const$1 = RuntimeHelper.upcallHandle(fuse_operations.bmap.class, "apply", constants$26.const$1);
-    static final VarHandle const$2 = constants$9.const$4.varHandle(MemoryLayout.PathElement.groupElement("bmap"));
-    static final FunctionDescriptor const$3 = FunctionDescriptor.of(JAVA_INT,
-        RuntimeHelper.POINTER,
-        JAVA_INT,
-        RuntimeHelper.POINTER,
-        RuntimeHelper.POINTER,
-        JAVA_INT,
-        RuntimeHelper.POINTER
-    );
-    static final MethodHandle const$4 = RuntimeHelper.upcallHandle(fuse_operations.ioctl.class, "apply", constants$28.const$3);
-    static final MethodHandle const$5 = RuntimeHelper.downcallHandle(
-        constants$28.const$3
-    );
-}
-
-
diff --git a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/constants$29.java b/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/constants$29.java
deleted file mode 100644
index 03131b7b..00000000
--- a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/constants$29.java
+++ /dev/null
@@ -1,29 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.mac.extr.fuse;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$29 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$29() {}
-    static final VarHandle const$0 = constants$9.const$4.varHandle(MemoryLayout.PathElement.groupElement("ioctl"));
-    static final MethodHandle const$1 = RuntimeHelper.upcallHandle(fuse_operations.poll.class, "apply", constants$4.const$0);
-    static final MethodHandle const$2 = RuntimeHelper.downcallHandle(
-        constants$4.const$0
-    );
-    static final VarHandle const$3 = constants$9.const$4.varHandle(MemoryLayout.PathElement.groupElement("poll"));
-    static final FunctionDescriptor const$4 = FunctionDescriptor.of(JAVA_INT,
-        RuntimeHelper.POINTER,
-        RuntimeHelper.POINTER,
-        JAVA_LONG,
-        RuntimeHelper.POINTER
-    );
-    static final MethodHandle const$5 = RuntimeHelper.upcallHandle(fuse_operations.write_buf.class, "apply", constants$29.const$4);
-}
-
-
diff --git a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/constants$3.java b/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/constants$3.java
deleted file mode 100644
index 5727f9da..00000000
--- a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/constants$3.java
+++ /dev/null
@@ -1,34 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.mac.extr.fuse;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$3 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$3() {}
-    static final VarHandle const$0 = constants$1.const$4.varHandle(MemoryLayout.PathElement.groupElement("max_background"));
-    static final VarHandle const$1 = constants$1.const$4.varHandle(MemoryLayout.PathElement.groupElement("congestion_threshold"));
-    static final FunctionDescriptor const$2 = FunctionDescriptor.of(RuntimeHelper.POINTER,
-        RuntimeHelper.POINTER,
-        RuntimeHelper.POINTER
-    );
-    static final MethodHandle const$3 = RuntimeHelper.downcallHandle(
-        "fuse_mount",
-        constants$3.const$2
-    );
-    static final FunctionDescriptor const$4 = FunctionDescriptor.ofVoid(
-        RuntimeHelper.POINTER,
-        RuntimeHelper.POINTER
-    );
-    static final MethodHandle const$5 = RuntimeHelper.downcallHandle(
-        "fuse_unmount",
-        constants$3.const$4
-    );
-}
-
-
diff --git a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/constants$30.java b/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/constants$30.java
deleted file mode 100644
index a4ca5553..00000000
--- a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/constants$30.java
+++ /dev/null
@@ -1,28 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.mac.extr.fuse;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$30 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$30() {}
-    static final MethodHandle const$0 = RuntimeHelper.downcallHandle(
-        constants$29.const$4
-    );
-    static final VarHandle const$1 = constants$9.const$4.varHandle(MemoryLayout.PathElement.groupElement("write_buf"));
-    static final MethodHandle const$2 = RuntimeHelper.upcallHandle(fuse_operations.read_buf.class, "apply", constants$17.const$3);
-    static final VarHandle const$3 = constants$9.const$4.varHandle(MemoryLayout.PathElement.groupElement("read_buf"));
-    static final FunctionDescriptor const$4 = FunctionDescriptor.of(JAVA_INT,
-        RuntimeHelper.POINTER,
-        RuntimeHelper.POINTER,
-        JAVA_INT
-    );
-    static final MethodHandle const$5 = RuntimeHelper.upcallHandle(fuse_operations.flock.class, "apply", constants$30.const$4);
-}
-
-
diff --git a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/constants$31.java b/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/constants$31.java
deleted file mode 100644
index c5558141..00000000
--- a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/constants$31.java
+++ /dev/null
@@ -1,32 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.mac.extr.fuse;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$31 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$31() {}
-    static final MethodHandle const$0 = RuntimeHelper.downcallHandle(
-        constants$30.const$4
-    );
-    static final VarHandle const$1 = constants$9.const$4.varHandle(MemoryLayout.PathElement.groupElement("flock"));
-    static final FunctionDescriptor const$2 = FunctionDescriptor.of(JAVA_INT,
-        RuntimeHelper.POINTER,
-        JAVA_INT,
-        JAVA_LONG,
-        JAVA_LONG,
-        RuntimeHelper.POINTER
-    );
-    static final MethodHandle const$3 = RuntimeHelper.upcallHandle(fuse_operations.fallocate.class, "apply", constants$31.const$2);
-    static final MethodHandle const$4 = RuntimeHelper.downcallHandle(
-        constants$31.const$2
-    );
-    static final VarHandle const$5 = constants$9.const$4.varHandle(MemoryLayout.PathElement.groupElement("fallocate"));
-}
-
-
diff --git a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/constants$32.java b/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/constants$32.java
deleted file mode 100644
index 8cb30bd0..00000000
--- a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/constants$32.java
+++ /dev/null
@@ -1,43 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.mac.extr.fuse;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$32 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$32() {}
-    static final FunctionDescriptor const$0 = FunctionDescriptor.of(RuntimeHelper.POINTER,
-        RuntimeHelper.POINTER,
-        RuntimeHelper.POINTER,
-        RuntimeHelper.POINTER,
-        JAVA_LONG,
-        RuntimeHelper.POINTER
-    );
-    static final MethodHandle const$1 = RuntimeHelper.downcallHandle(
-        "fuse_new",
-        constants$32.const$0
-    );
-    static final MethodHandle const$2 = RuntimeHelper.downcallHandle(
-        "fuse_destroy",
-        constants$24.const$1
-    );
-    static final MethodHandle const$3 = RuntimeHelper.downcallHandle(
-        "fuse_loop",
-        constants$13.const$1
-    );
-    static final MethodHandle const$4 = RuntimeHelper.downcallHandle(
-        "fuse_exit",
-        constants$24.const$1
-    );
-    static final MethodHandle const$5 = RuntimeHelper.downcallHandle(
-        "fuse_loop_mt",
-        constants$13.const$1
-    );
-}
-
-
diff --git a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/constants$4.java b/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/constants$4.java
deleted file mode 100644
index 1320e1df..00000000
--- a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/constants$4.java
+++ /dev/null
@@ -1,65 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.mac.extr.fuse;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$4 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$4() {}
-    static final FunctionDescriptor const$0 = FunctionDescriptor.of(JAVA_INT,
-        RuntimeHelper.POINTER,
-        RuntimeHelper.POINTER,
-        RuntimeHelper.POINTER,
-        RuntimeHelper.POINTER
-    );
-    static final MethodHandle const$1 = RuntimeHelper.downcallHandle(
-        "fuse_parse_cmdline",
-        constants$4.const$0
-    );
-    static final StructLayout const$2 = MemoryLayout.structLayout(
-        JAVA_LONG.withName("tv_sec"),
-        JAVA_LONG.withName("tv_nsec")
-    ).withName("timespec");
-    static final VarHandle const$3 = constants$4.const$2.varHandle(MemoryLayout.PathElement.groupElement("tv_sec"));
-    static final VarHandle const$4 = constants$4.const$2.varHandle(MemoryLayout.PathElement.groupElement("tv_nsec"));
-    static final StructLayout const$5 = MemoryLayout.structLayout(
-        JAVA_INT.withName("st_dev"),
-        JAVA_SHORT.withName("st_mode"),
-        JAVA_SHORT.withName("st_nlink"),
-        JAVA_LONG.withName("st_ino"),
-        JAVA_INT.withName("st_uid"),
-        JAVA_INT.withName("st_gid"),
-        JAVA_INT.withName("st_rdev"),
-        MemoryLayout.paddingLayout(4),
-        MemoryLayout.structLayout(
-            JAVA_LONG.withName("tv_sec"),
-            JAVA_LONG.withName("tv_nsec")
-        ).withName("st_atimespec"),
-        MemoryLayout.structLayout(
-            JAVA_LONG.withName("tv_sec"),
-            JAVA_LONG.withName("tv_nsec")
-        ).withName("st_mtimespec"),
-        MemoryLayout.structLayout(
-            JAVA_LONG.withName("tv_sec"),
-            JAVA_LONG.withName("tv_nsec")
-        ).withName("st_ctimespec"),
-        MemoryLayout.structLayout(
-            JAVA_LONG.withName("tv_sec"),
-            JAVA_LONG.withName("tv_nsec")
-        ).withName("st_birthtimespec"),
-        JAVA_LONG.withName("st_size"),
-        JAVA_LONG.withName("st_blocks"),
-        JAVA_INT.withName("st_blksize"),
-        JAVA_INT.withName("st_flags"),
-        JAVA_INT.withName("st_gen"),
-        JAVA_INT.withName("st_lspare"),
-        MemoryLayout.sequenceLayout(2, JAVA_LONG).withName("st_qspare")
-    ).withName("stat");
-}
-
-
diff --git a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/constants$5.java b/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/constants$5.java
deleted file mode 100644
index b443e181..00000000
--- a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/constants$5.java
+++ /dev/null
@@ -1,22 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.mac.extr.fuse;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$5 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$5() {}
-    static final VarHandle const$0 = constants$4.const$5.varHandle(MemoryLayout.PathElement.groupElement("st_dev"));
-    static final VarHandle const$1 = constants$4.const$5.varHandle(MemoryLayout.PathElement.groupElement("st_mode"));
-    static final VarHandle const$2 = constants$4.const$5.varHandle(MemoryLayout.PathElement.groupElement("st_nlink"));
-    static final VarHandle const$3 = constants$4.const$5.varHandle(MemoryLayout.PathElement.groupElement("st_ino"));
-    static final VarHandle const$4 = constants$4.const$5.varHandle(MemoryLayout.PathElement.groupElement("st_uid"));
-    static final VarHandle const$5 = constants$4.const$5.varHandle(MemoryLayout.PathElement.groupElement("st_gid"));
-}
-
-
diff --git a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/constants$6.java b/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/constants$6.java
deleted file mode 100644
index 2512b58e..00000000
--- a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/constants$6.java
+++ /dev/null
@@ -1,22 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.mac.extr.fuse;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$6 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$6() {}
-    static final VarHandle const$0 = constants$4.const$5.varHandle(MemoryLayout.PathElement.groupElement("st_rdev"));
-    static final VarHandle const$1 = constants$4.const$5.varHandle(MemoryLayout.PathElement.groupElement("st_size"));
-    static final VarHandle const$2 = constants$4.const$5.varHandle(MemoryLayout.PathElement.groupElement("st_blocks"));
-    static final VarHandle const$3 = constants$4.const$5.varHandle(MemoryLayout.PathElement.groupElement("st_blksize"));
-    static final VarHandle const$4 = constants$4.const$5.varHandle(MemoryLayout.PathElement.groupElement("st_flags"));
-    static final VarHandle const$5 = constants$4.const$5.varHandle(MemoryLayout.PathElement.groupElement("st_gen"));
-}
-
-
diff --git a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/constants$7.java b/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/constants$7.java
deleted file mode 100644
index e3688f85..00000000
--- a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/constants$7.java
+++ /dev/null
@@ -1,34 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.mac.extr.fuse;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$7 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$7() {}
-    static final VarHandle const$0 = constants$4.const$5.varHandle(MemoryLayout.PathElement.groupElement("st_lspare"));
-    static final StructLayout const$1 = MemoryLayout.structLayout(
-        JAVA_LONG.withName("f_bsize"),
-        JAVA_LONG.withName("f_frsize"),
-        JAVA_INT.withName("f_blocks"),
-        JAVA_INT.withName("f_bfree"),
-        JAVA_INT.withName("f_bavail"),
-        JAVA_INT.withName("f_files"),
-        JAVA_INT.withName("f_ffree"),
-        JAVA_INT.withName("f_favail"),
-        JAVA_LONG.withName("f_fsid"),
-        JAVA_LONG.withName("f_flag"),
-        JAVA_LONG.withName("f_namemax")
-    ).withName("statvfs");
-    static final VarHandle const$2 = constants$7.const$1.varHandle(MemoryLayout.PathElement.groupElement("f_bsize"));
-    static final VarHandle const$3 = constants$7.const$1.varHandle(MemoryLayout.PathElement.groupElement("f_frsize"));
-    static final VarHandle const$4 = constants$7.const$1.varHandle(MemoryLayout.PathElement.groupElement("f_blocks"));
-    static final VarHandle const$5 = constants$7.const$1.varHandle(MemoryLayout.PathElement.groupElement("f_bfree"));
-}
-
-
diff --git a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/constants$8.java b/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/constants$8.java
deleted file mode 100644
index da5ccfd7..00000000
--- a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/constants$8.java
+++ /dev/null
@@ -1,22 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.mac.extr.fuse;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$8 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$8() {}
-    static final VarHandle const$0 = constants$7.const$1.varHandle(MemoryLayout.PathElement.groupElement("f_bavail"));
-    static final VarHandle const$1 = constants$7.const$1.varHandle(MemoryLayout.PathElement.groupElement("f_files"));
-    static final VarHandle const$2 = constants$7.const$1.varHandle(MemoryLayout.PathElement.groupElement("f_ffree"));
-    static final VarHandle const$3 = constants$7.const$1.varHandle(MemoryLayout.PathElement.groupElement("f_favail"));
-    static final VarHandle const$4 = constants$7.const$1.varHandle(MemoryLayout.PathElement.groupElement("f_fsid"));
-    static final VarHandle const$5 = constants$7.const$1.varHandle(MemoryLayout.PathElement.groupElement("f_flag"));
-}
-
-
diff --git a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/constants$9.java b/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/constants$9.java
deleted file mode 100644
index a417567b..00000000
--- a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/constants$9.java
+++ /dev/null
@@ -1,78 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.mac.extr.fuse;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$9 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$9() {}
-    static final VarHandle const$0 = constants$7.const$1.varHandle(MemoryLayout.PathElement.groupElement("f_namemax"));
-    static final FunctionDescriptor const$1 = FunctionDescriptor.of(JAVA_INT,
-        RuntimeHelper.POINTER,
-        RuntimeHelper.POINTER,
-        RuntimeHelper.POINTER,
-        JAVA_LONG
-    );
-    static final MethodHandle const$2 = RuntimeHelper.upcallHandle(fuse_fill_dir_t.class, "apply", constants$9.const$1);
-    static final MethodHandle const$3 = RuntimeHelper.downcallHandle(
-        constants$9.const$1
-    );
-    static final StructLayout const$4 = MemoryLayout.structLayout(
-        RuntimeHelper.POINTER.withName("getattr"),
-        RuntimeHelper.POINTER.withName("readlink"),
-        RuntimeHelper.POINTER.withName("getdir"),
-        RuntimeHelper.POINTER.withName("mknod"),
-        RuntimeHelper.POINTER.withName("mkdir"),
-        RuntimeHelper.POINTER.withName("unlink"),
-        RuntimeHelper.POINTER.withName("rmdir"),
-        RuntimeHelper.POINTER.withName("symlink"),
-        RuntimeHelper.POINTER.withName("rename"),
-        RuntimeHelper.POINTER.withName("link"),
-        RuntimeHelper.POINTER.withName("chmod"),
-        RuntimeHelper.POINTER.withName("chown"),
-        RuntimeHelper.POINTER.withName("truncate"),
-        RuntimeHelper.POINTER.withName("utime"),
-        RuntimeHelper.POINTER.withName("open"),
-        RuntimeHelper.POINTER.withName("read"),
-        RuntimeHelper.POINTER.withName("write"),
-        RuntimeHelper.POINTER.withName("statfs"),
-        RuntimeHelper.POINTER.withName("flush"),
-        RuntimeHelper.POINTER.withName("release"),
-        RuntimeHelper.POINTER.withName("fsync"),
-        RuntimeHelper.POINTER.withName("setxattr"),
-        RuntimeHelper.POINTER.withName("getxattr"),
-        RuntimeHelper.POINTER.withName("listxattr"),
-        RuntimeHelper.POINTER.withName("removexattr"),
-        RuntimeHelper.POINTER.withName("opendir"),
-        RuntimeHelper.POINTER.withName("readdir"),
-        RuntimeHelper.POINTER.withName("releasedir"),
-        RuntimeHelper.POINTER.withName("fsyncdir"),
-        RuntimeHelper.POINTER.withName("init"),
-        RuntimeHelper.POINTER.withName("destroy"),
-        RuntimeHelper.POINTER.withName("access"),
-        RuntimeHelper.POINTER.withName("create"),
-        RuntimeHelper.POINTER.withName("ftruncate"),
-        RuntimeHelper.POINTER.withName("fgetattr"),
-        RuntimeHelper.POINTER.withName("lock"),
-        RuntimeHelper.POINTER.withName("utimens"),
-        RuntimeHelper.POINTER.withName("bmap"),
-        MemoryLayout.paddingLayout(8),
-        RuntimeHelper.POINTER.withName("ioctl"),
-        RuntimeHelper.POINTER.withName("poll"),
-        RuntimeHelper.POINTER.withName("write_buf"),
-        RuntimeHelper.POINTER.withName("read_buf"),
-        RuntimeHelper.POINTER.withName("flock"),
-        RuntimeHelper.POINTER.withName("fallocate")
-    ).withName("fuse_operations");
-    static final FunctionDescriptor const$5 = FunctionDescriptor.of(JAVA_INT,
-        RuntimeHelper.POINTER,
-        RuntimeHelper.POINTER
-    );
-}
-
-
diff --git a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/fuse_args.java b/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/fuse_args.java
index 73d6241d..6efabf63 100644
--- a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/fuse_args.java
+++ b/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/fuse_args.java
@@ -2,112 +2,220 @@
 
 package org.cryptomator.jfuse.mac.extr.fuse;
 
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
+import java.lang.invoke.*;
 import java.lang.foreign.*;
+import java.nio.ByteOrder;
+import java.util.*;
+import java.util.function.*;
+import java.util.stream.*;
+
 import static java.lang.foreign.ValueLayout.*;
+import static java.lang.foreign.MemoryLayout.PathElement.*;
+
 /**
- * {@snippet :
+ * {@snippet lang=c :
  * struct fuse_args {
  *     int argc;
- *     char** argv;
+ *     char **argv;
  *     int allocated;
- * };
+ * }
  * }
  */
 public class fuse_args {
 
-    public static MemoryLayout $LAYOUT() {
-        return constants$0.const$0;
+    fuse_args() {
+        // Should not be called directly
+    }
+
+    private static final GroupLayout $LAYOUT = MemoryLayout.structLayout(
+        fuse_h.C_INT.withName("argc"),
+        MemoryLayout.paddingLayout(4),
+        fuse_h.C_POINTER.withName("argv"),
+        fuse_h.C_INT.withName("allocated"),
+        MemoryLayout.paddingLayout(4)
+    ).withName("fuse_args");
+
+    /**
+     * The layout of this struct
+     */
+    public static final GroupLayout layout() {
+        return $LAYOUT;
     }
-    public static VarHandle argc$VH() {
-        return constants$0.const$1;
+
+    private static final OfInt argc$LAYOUT = (OfInt)$LAYOUT.select(groupElement("argc"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int argc
+     * }
+     */
+    public static final OfInt argc$layout() {
+        return argc$LAYOUT;
     }
+
+    private static final long argc$OFFSET = 0;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int argc
+     * }
+     */
+    public static final long argc$offset() {
+        return argc$OFFSET;
+    }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int argc;
+     * {@snippet lang=c :
+     * int argc
      * }
      */
-    public static int argc$get(MemorySegment seg) {
-        return (int)constants$0.const$1.get(seg);
+    public static int argc(MemorySegment struct) {
+        return struct.get(argc$LAYOUT, argc$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int argc;
+     * {@snippet lang=c :
+     * int argc
      * }
      */
-    public static void argc$set(MemorySegment seg, int x) {
-        constants$0.const$1.set(seg, x);
+    public static void argc(MemorySegment struct, int fieldValue) {
+        struct.set(argc$LAYOUT, argc$OFFSET, fieldValue);
     }
-    public static int argc$get(MemorySegment seg, long index) {
-        return (int)constants$0.const$1.get(seg.asSlice(index*sizeof()));
-    }
-    public static void argc$set(MemorySegment seg, long index, int x) {
-        constants$0.const$1.set(seg.asSlice(index*sizeof()), x);
+
+    private static final AddressLayout argv$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("argv"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * char **argv
+     * }
+     */
+    public static final AddressLayout argv$layout() {
+        return argv$LAYOUT;
     }
-    public static VarHandle argv$VH() {
-        return constants$0.const$2;
+
+    private static final long argv$OFFSET = 8;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * char **argv
+     * }
+     */
+    public static final long argv$offset() {
+        return argv$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * char** argv;
+     * {@snippet lang=c :
+     * char **argv
      * }
      */
-    public static MemorySegment argv$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$0.const$2.get(seg);
+    public static MemorySegment argv(MemorySegment struct) {
+        return struct.get(argv$LAYOUT, argv$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * char** argv;
+     * {@snippet lang=c :
+     * char **argv
      * }
      */
-    public static void argv$set(MemorySegment seg, MemorySegment x) {
-        constants$0.const$2.set(seg, x);
-    }
-    public static MemorySegment argv$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$0.const$2.get(seg.asSlice(index*sizeof()));
+    public static void argv(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(argv$LAYOUT, argv$OFFSET, fieldValue);
     }
-    public static void argv$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$0.const$2.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt allocated$LAYOUT = (OfInt)$LAYOUT.select(groupElement("allocated"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int allocated
+     * }
+     */
+    public static final OfInt allocated$layout() {
+        return allocated$LAYOUT;
     }
-    public static VarHandle allocated$VH() {
-        return constants$0.const$3;
+
+    private static final long allocated$OFFSET = 16;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int allocated
+     * }
+     */
+    public static final long allocated$offset() {
+        return allocated$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int allocated;
+     * {@snippet lang=c :
+     * int allocated
      * }
      */
-    public static int allocated$get(MemorySegment seg) {
-        return (int)constants$0.const$3.get(seg);
+    public static int allocated(MemorySegment struct) {
+        return struct.get(allocated$LAYOUT, allocated$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int allocated;
+     * {@snippet lang=c :
+     * int allocated
      * }
      */
-    public static void allocated$set(MemorySegment seg, int x) {
-        constants$0.const$3.set(seg, x);
+    public static void allocated(MemorySegment struct, int fieldValue) {
+        struct.set(allocated$LAYOUT, allocated$OFFSET, fieldValue);
     }
-    public static int allocated$get(MemorySegment seg, long index) {
-        return (int)constants$0.const$3.get(seg.asSlice(index*sizeof()));
+
+    /**
+     * Obtains a slice of {@code arrayParam} which selects the array element at {@code index}.
+     * The returned segment has address {@code arrayParam.address() + index * layout().byteSize()}
+     */
+    public static MemorySegment asSlice(MemorySegment array, long index) {
+        return array.asSlice(layout().byteSize() * index);
     }
-    public static void allocated$set(MemorySegment seg, long index, int x) {
-        constants$0.const$3.set(seg.asSlice(index*sizeof()), x);
+
+    /**
+     * The size (in bytes) of this struct
+     */
+    public static long sizeof() { return layout().byteSize(); }
+
+    /**
+     * Allocate a segment of size {@code layout().byteSize()} using {@code allocator}
+     */
+    public static MemorySegment allocate(SegmentAllocator allocator) {
+        return allocator.allocate(layout());
     }
-    public static long sizeof() { return $LAYOUT().byteSize(); }
-    public static MemorySegment allocate(SegmentAllocator allocator) { return allocator.allocate($LAYOUT()); }
-    public static MemorySegment allocateArray(long len, SegmentAllocator allocator) {
-        return allocator.allocate(MemoryLayout.sequenceLayout(len, $LAYOUT()));
+
+    /**
+     * Allocate an array of size {@code elementCount} using {@code allocator}.
+     * The returned segment has size {@code elementCount * layout().byteSize()}.
+     */
+    public static MemorySegment allocateArray(long elementCount, SegmentAllocator allocator) {
+        return allocator.allocate(MemoryLayout.sequenceLayout(elementCount, layout()));
     }
-    public static MemorySegment ofAddress(MemorySegment addr, Arena scope) { return RuntimeHelper.asArray(addr, $LAYOUT(), 1, scope); }
-}
 
+    /**
+     * Reinterprets {@code addr} using target {@code arena} and {@code cleanupAction) (if any).
+     * The returned segment has size {@code layout().byteSize()}
+     */
+    public static MemorySegment reinterpret(MemorySegment addr, Arena arena, Consumer<MemorySegment> cleanup) {
+        return reinterpret(addr, 1, arena, cleanup);
+    }
+
+    /**
+     * Reinterprets {@code addr} using target {@code arena} and {@code cleanupAction) (if any).
+     * The returned segment has size {@code elementCount * layout().byteSize()}
+     */
+    public static MemorySegment reinterpret(MemorySegment addr, long elementCount, Arena arena, Consumer<MemorySegment> cleanup) {
+        return addr.reinterpret(layout().byteSize() * elementCount, arena, cleanup);
+    }
+}
 
diff --git a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/fuse_conn_info.java b/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/fuse_conn_info.java
index 306c464d..e8299176 100644
--- a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/fuse_conn_info.java
+++ b/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/fuse_conn_info.java
@@ -2,13 +2,18 @@
 
 package org.cryptomator.jfuse.mac.extr.fuse;
 
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
+import java.lang.invoke.*;
 import java.lang.foreign.*;
+import java.nio.ByteOrder;
+import java.util.*;
+import java.util.function.*;
+import java.util.stream.*;
+
 import static java.lang.foreign.ValueLayout.*;
+import static java.lang.foreign.MemoryLayout.PathElement.*;
+
 /**
- * {@snippet :
+ * {@snippet lang=c :
  * struct fuse_conn_info {
  *     unsigned int proto_major;
  *     unsigned int proto_minor;
@@ -20,266 +25,550 @@
  *     unsigned int max_background;
  *     unsigned int congestion_threshold;
  *     unsigned int reserved[23];
- * };
+ * }
  * }
  */
 public class fuse_conn_info {
 
-    public static MemoryLayout $LAYOUT() {
-        return constants$1.const$4;
+    fuse_conn_info() {
+        // Should not be called directly
+    }
+
+    private static final GroupLayout $LAYOUT = MemoryLayout.structLayout(
+        fuse_h.C_INT.withName("proto_major"),
+        fuse_h.C_INT.withName("proto_minor"),
+        fuse_h.C_INT.withName("async_read"),
+        fuse_h.C_INT.withName("max_write"),
+        fuse_h.C_INT.withName("max_readahead"),
+        fuse_h.C_INT.withName("capable"),
+        fuse_h.C_INT.withName("want"),
+        fuse_h.C_INT.withName("max_background"),
+        fuse_h.C_INT.withName("congestion_threshold"),
+        MemoryLayout.sequenceLayout(23, fuse_h.C_INT).withName("reserved")
+    ).withName("fuse_conn_info");
+
+    /**
+     * The layout of this struct
+     */
+    public static final GroupLayout layout() {
+        return $LAYOUT;
+    }
+
+    private static final OfInt proto_major$LAYOUT = (OfInt)$LAYOUT.select(groupElement("proto_major"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * unsigned int proto_major
+     * }
+     */
+    public static final OfInt proto_major$layout() {
+        return proto_major$LAYOUT;
     }
-    public static VarHandle proto_major$VH() {
-        return constants$1.const$5;
+
+    private static final long proto_major$OFFSET = 0;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * unsigned int proto_major
+     * }
+     */
+    public static final long proto_major$offset() {
+        return proto_major$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned int proto_major;
+     * {@snippet lang=c :
+     * unsigned int proto_major
      * }
      */
-    public static int proto_major$get(MemorySegment seg) {
-        return (int)constants$1.const$5.get(seg);
+    public static int proto_major(MemorySegment struct) {
+        return struct.get(proto_major$LAYOUT, proto_major$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned int proto_major;
+     * {@snippet lang=c :
+     * unsigned int proto_major
      * }
      */
-    public static void proto_major$set(MemorySegment seg, int x) {
-        constants$1.const$5.set(seg, x);
-    }
-    public static int proto_major$get(MemorySegment seg, long index) {
-        return (int)constants$1.const$5.get(seg.asSlice(index*sizeof()));
+    public static void proto_major(MemorySegment struct, int fieldValue) {
+        struct.set(proto_major$LAYOUT, proto_major$OFFSET, fieldValue);
     }
-    public static void proto_major$set(MemorySegment seg, long index, int x) {
-        constants$1.const$5.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt proto_minor$LAYOUT = (OfInt)$LAYOUT.select(groupElement("proto_minor"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * unsigned int proto_minor
+     * }
+     */
+    public static final OfInt proto_minor$layout() {
+        return proto_minor$LAYOUT;
     }
-    public static VarHandle proto_minor$VH() {
-        return constants$2.const$0;
+
+    private static final long proto_minor$OFFSET = 4;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * unsigned int proto_minor
+     * }
+     */
+    public static final long proto_minor$offset() {
+        return proto_minor$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned int proto_minor;
+     * {@snippet lang=c :
+     * unsigned int proto_minor
      * }
      */
-    public static int proto_minor$get(MemorySegment seg) {
-        return (int)constants$2.const$0.get(seg);
+    public static int proto_minor(MemorySegment struct) {
+        return struct.get(proto_minor$LAYOUT, proto_minor$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned int proto_minor;
+     * {@snippet lang=c :
+     * unsigned int proto_minor
      * }
      */
-    public static void proto_minor$set(MemorySegment seg, int x) {
-        constants$2.const$0.set(seg, x);
+    public static void proto_minor(MemorySegment struct, int fieldValue) {
+        struct.set(proto_minor$LAYOUT, proto_minor$OFFSET, fieldValue);
     }
-    public static int proto_minor$get(MemorySegment seg, long index) {
-        return (int)constants$2.const$0.get(seg.asSlice(index*sizeof()));
-    }
-    public static void proto_minor$set(MemorySegment seg, long index, int x) {
-        constants$2.const$0.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt async_read$LAYOUT = (OfInt)$LAYOUT.select(groupElement("async_read"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * unsigned int async_read
+     * }
+     */
+    public static final OfInt async_read$layout() {
+        return async_read$LAYOUT;
     }
-    public static VarHandle async_read$VH() {
-        return constants$2.const$1;
+
+    private static final long async_read$OFFSET = 8;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * unsigned int async_read
+     * }
+     */
+    public static final long async_read$offset() {
+        return async_read$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned int async_read;
+     * {@snippet lang=c :
+     * unsigned int async_read
      * }
      */
-    public static int async_read$get(MemorySegment seg) {
-        return (int)constants$2.const$1.get(seg);
+    public static int async_read(MemorySegment struct) {
+        return struct.get(async_read$LAYOUT, async_read$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned int async_read;
+     * {@snippet lang=c :
+     * unsigned int async_read
      * }
      */
-    public static void async_read$set(MemorySegment seg, int x) {
-        constants$2.const$1.set(seg, x);
-    }
-    public static int async_read$get(MemorySegment seg, long index) {
-        return (int)constants$2.const$1.get(seg.asSlice(index*sizeof()));
+    public static void async_read(MemorySegment struct, int fieldValue) {
+        struct.set(async_read$LAYOUT, async_read$OFFSET, fieldValue);
     }
-    public static void async_read$set(MemorySegment seg, long index, int x) {
-        constants$2.const$1.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt max_write$LAYOUT = (OfInt)$LAYOUT.select(groupElement("max_write"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * unsigned int max_write
+     * }
+     */
+    public static final OfInt max_write$layout() {
+        return max_write$LAYOUT;
     }
-    public static VarHandle max_write$VH() {
-        return constants$2.const$2;
+
+    private static final long max_write$OFFSET = 12;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * unsigned int max_write
+     * }
+     */
+    public static final long max_write$offset() {
+        return max_write$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned int max_write;
+     * {@snippet lang=c :
+     * unsigned int max_write
      * }
      */
-    public static int max_write$get(MemorySegment seg) {
-        return (int)constants$2.const$2.get(seg);
+    public static int max_write(MemorySegment struct) {
+        return struct.get(max_write$LAYOUT, max_write$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned int max_write;
+     * {@snippet lang=c :
+     * unsigned int max_write
      * }
      */
-    public static void max_write$set(MemorySegment seg, int x) {
-        constants$2.const$2.set(seg, x);
+    public static void max_write(MemorySegment struct, int fieldValue) {
+        struct.set(max_write$LAYOUT, max_write$OFFSET, fieldValue);
     }
-    public static int max_write$get(MemorySegment seg, long index) {
-        return (int)constants$2.const$2.get(seg.asSlice(index*sizeof()));
-    }
-    public static void max_write$set(MemorySegment seg, long index, int x) {
-        constants$2.const$2.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt max_readahead$LAYOUT = (OfInt)$LAYOUT.select(groupElement("max_readahead"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * unsigned int max_readahead
+     * }
+     */
+    public static final OfInt max_readahead$layout() {
+        return max_readahead$LAYOUT;
     }
-    public static VarHandle max_readahead$VH() {
-        return constants$2.const$3;
+
+    private static final long max_readahead$OFFSET = 16;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * unsigned int max_readahead
+     * }
+     */
+    public static final long max_readahead$offset() {
+        return max_readahead$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned int max_readahead;
+     * {@snippet lang=c :
+     * unsigned int max_readahead
      * }
      */
-    public static int max_readahead$get(MemorySegment seg) {
-        return (int)constants$2.const$3.get(seg);
+    public static int max_readahead(MemorySegment struct) {
+        return struct.get(max_readahead$LAYOUT, max_readahead$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned int max_readahead;
+     * {@snippet lang=c :
+     * unsigned int max_readahead
      * }
      */
-    public static void max_readahead$set(MemorySegment seg, int x) {
-        constants$2.const$3.set(seg, x);
-    }
-    public static int max_readahead$get(MemorySegment seg, long index) {
-        return (int)constants$2.const$3.get(seg.asSlice(index*sizeof()));
+    public static void max_readahead(MemorySegment struct, int fieldValue) {
+        struct.set(max_readahead$LAYOUT, max_readahead$OFFSET, fieldValue);
     }
-    public static void max_readahead$set(MemorySegment seg, long index, int x) {
-        constants$2.const$3.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt capable$LAYOUT = (OfInt)$LAYOUT.select(groupElement("capable"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * unsigned int capable
+     * }
+     */
+    public static final OfInt capable$layout() {
+        return capable$LAYOUT;
     }
-    public static VarHandle capable$VH() {
-        return constants$2.const$4;
+
+    private static final long capable$OFFSET = 20;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * unsigned int capable
+     * }
+     */
+    public static final long capable$offset() {
+        return capable$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned int capable;
+     * {@snippet lang=c :
+     * unsigned int capable
      * }
      */
-    public static int capable$get(MemorySegment seg) {
-        return (int)constants$2.const$4.get(seg);
+    public static int capable(MemorySegment struct) {
+        return struct.get(capable$LAYOUT, capable$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned int capable;
+     * {@snippet lang=c :
+     * unsigned int capable
      * }
      */
-    public static void capable$set(MemorySegment seg, int x) {
-        constants$2.const$4.set(seg, x);
+    public static void capable(MemorySegment struct, int fieldValue) {
+        struct.set(capable$LAYOUT, capable$OFFSET, fieldValue);
     }
-    public static int capable$get(MemorySegment seg, long index) {
-        return (int)constants$2.const$4.get(seg.asSlice(index*sizeof()));
-    }
-    public static void capable$set(MemorySegment seg, long index, int x) {
-        constants$2.const$4.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt want$LAYOUT = (OfInt)$LAYOUT.select(groupElement("want"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * unsigned int want
+     * }
+     */
+    public static final OfInt want$layout() {
+        return want$LAYOUT;
     }
-    public static VarHandle want$VH() {
-        return constants$2.const$5;
+
+    private static final long want$OFFSET = 24;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * unsigned int want
+     * }
+     */
+    public static final long want$offset() {
+        return want$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned int want;
+     * {@snippet lang=c :
+     * unsigned int want
      * }
      */
-    public static int want$get(MemorySegment seg) {
-        return (int)constants$2.const$5.get(seg);
+    public static int want(MemorySegment struct) {
+        return struct.get(want$LAYOUT, want$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned int want;
+     * {@snippet lang=c :
+     * unsigned int want
      * }
      */
-    public static void want$set(MemorySegment seg, int x) {
-        constants$2.const$5.set(seg, x);
-    }
-    public static int want$get(MemorySegment seg, long index) {
-        return (int)constants$2.const$5.get(seg.asSlice(index*sizeof()));
+    public static void want(MemorySegment struct, int fieldValue) {
+        struct.set(want$LAYOUT, want$OFFSET, fieldValue);
     }
-    public static void want$set(MemorySegment seg, long index, int x) {
-        constants$2.const$5.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt max_background$LAYOUT = (OfInt)$LAYOUT.select(groupElement("max_background"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * unsigned int max_background
+     * }
+     */
+    public static final OfInt max_background$layout() {
+        return max_background$LAYOUT;
     }
-    public static VarHandle max_background$VH() {
-        return constants$3.const$0;
+
+    private static final long max_background$OFFSET = 28;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * unsigned int max_background
+     * }
+     */
+    public static final long max_background$offset() {
+        return max_background$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned int max_background;
+     * {@snippet lang=c :
+     * unsigned int max_background
      * }
      */
-    public static int max_background$get(MemorySegment seg) {
-        return (int)constants$3.const$0.get(seg);
+    public static int max_background(MemorySegment struct) {
+        return struct.get(max_background$LAYOUT, max_background$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned int max_background;
+     * {@snippet lang=c :
+     * unsigned int max_background
+     * }
+     */
+    public static void max_background(MemorySegment struct, int fieldValue) {
+        struct.set(max_background$LAYOUT, max_background$OFFSET, fieldValue);
+    }
+
+    private static final OfInt congestion_threshold$LAYOUT = (OfInt)$LAYOUT.select(groupElement("congestion_threshold"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * unsigned int congestion_threshold
      * }
      */
-    public static void max_background$set(MemorySegment seg, int x) {
-        constants$3.const$0.set(seg, x);
+    public static final OfInt congestion_threshold$layout() {
+        return congestion_threshold$LAYOUT;
     }
-    public static int max_background$get(MemorySegment seg, long index) {
-        return (int)constants$3.const$0.get(seg.asSlice(index*sizeof()));
+
+    private static final long congestion_threshold$OFFSET = 32;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * unsigned int congestion_threshold
+     * }
+     */
+    public static final long congestion_threshold$offset() {
+        return congestion_threshold$OFFSET;
     }
-    public static void max_background$set(MemorySegment seg, long index, int x) {
-        constants$3.const$0.set(seg.asSlice(index*sizeof()), x);
+
+    /**
+     * Getter for field:
+     * {@snippet lang=c :
+     * unsigned int congestion_threshold
+     * }
+     */
+    public static int congestion_threshold(MemorySegment struct) {
+        return struct.get(congestion_threshold$LAYOUT, congestion_threshold$OFFSET);
+    }
+
+    /**
+     * Setter for field:
+     * {@snippet lang=c :
+     * unsigned int congestion_threshold
+     * }
+     */
+    public static void congestion_threshold(MemorySegment struct, int fieldValue) {
+        struct.set(congestion_threshold$LAYOUT, congestion_threshold$OFFSET, fieldValue);
+    }
+
+    private static final SequenceLayout reserved$LAYOUT = (SequenceLayout)$LAYOUT.select(groupElement("reserved"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * unsigned int reserved[23]
+     * }
+     */
+    public static final SequenceLayout reserved$layout() {
+        return reserved$LAYOUT;
     }
-    public static VarHandle congestion_threshold$VH() {
-        return constants$3.const$1;
+
+    private static final long reserved$OFFSET = 36;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * unsigned int reserved[23]
+     * }
+     */
+    public static final long reserved$offset() {
+        return reserved$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned int congestion_threshold;
+     * {@snippet lang=c :
+     * unsigned int reserved[23]
      * }
      */
-    public static int congestion_threshold$get(MemorySegment seg) {
-        return (int)constants$3.const$1.get(seg);
+    public static MemorySegment reserved(MemorySegment struct) {
+        return struct.asSlice(reserved$OFFSET, reserved$LAYOUT.byteSize());
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned int congestion_threshold;
+     * {@snippet lang=c :
+     * unsigned int reserved[23]
+     * }
+     */
+    public static void reserved(MemorySegment struct, MemorySegment fieldValue) {
+        MemorySegment.copy(fieldValue, 0L, struct, reserved$OFFSET, reserved$LAYOUT.byteSize());
+    }
+
+    private static long[] reserved$DIMS = { 23 };
+
+    /**
+     * Dimensions for array field:
+     * {@snippet lang=c :
+     * unsigned int reserved[23]
+     * }
+     */
+    public static long[] reserved$dimensions() {
+        return reserved$DIMS;
+    }
+    private static final VarHandle reserved$ELEM_HANDLE = reserved$LAYOUT.varHandle(sequenceElement());
+
+    /**
+     * Indexed getter for field:
+     * {@snippet lang=c :
+     * unsigned int reserved[23]
+     * }
+     */
+    public static int reserved(MemorySegment struct, long index0) {
+        return (int)reserved$ELEM_HANDLE.get(struct, 0L, index0);
+    }
+
+    /**
+     * Indexed setter for field:
+     * {@snippet lang=c :
+     * unsigned int reserved[23]
      * }
      */
-    public static void congestion_threshold$set(MemorySegment seg, int x) {
-        constants$3.const$1.set(seg, x);
+    public static void reserved(MemorySegment struct, long index0, int fieldValue) {
+        reserved$ELEM_HANDLE.set(struct, 0L, index0, fieldValue);
     }
-    public static int congestion_threshold$get(MemorySegment seg, long index) {
-        return (int)constants$3.const$1.get(seg.asSlice(index*sizeof()));
+
+    /**
+     * Obtains a slice of {@code arrayParam} which selects the array element at {@code index}.
+     * The returned segment has address {@code arrayParam.address() + index * layout().byteSize()}
+     */
+    public static MemorySegment asSlice(MemorySegment array, long index) {
+        return array.asSlice(layout().byteSize() * index);
     }
-    public static void congestion_threshold$set(MemorySegment seg, long index, int x) {
-        constants$3.const$1.set(seg.asSlice(index*sizeof()), x);
+
+    /**
+     * The size (in bytes) of this struct
+     */
+    public static long sizeof() { return layout().byteSize(); }
+
+    /**
+     * Allocate a segment of size {@code layout().byteSize()} using {@code allocator}
+     */
+    public static MemorySegment allocate(SegmentAllocator allocator) {
+        return allocator.allocate(layout());
     }
-    public static MemorySegment reserved$slice(MemorySegment seg) {
-        return seg.asSlice(36, 92);
+
+    /**
+     * Allocate an array of size {@code elementCount} using {@code allocator}.
+     * The returned segment has size {@code elementCount * layout().byteSize()}.
+     */
+    public static MemorySegment allocateArray(long elementCount, SegmentAllocator allocator) {
+        return allocator.allocate(MemoryLayout.sequenceLayout(elementCount, layout()));
     }
-    public static long sizeof() { return $LAYOUT().byteSize(); }
-    public static MemorySegment allocate(SegmentAllocator allocator) { return allocator.allocate($LAYOUT()); }
-    public static MemorySegment allocateArray(long len, SegmentAllocator allocator) {
-        return allocator.allocate(MemoryLayout.sequenceLayout(len, $LAYOUT()));
+
+    /**
+     * Reinterprets {@code addr} using target {@code arena} and {@code cleanupAction) (if any).
+     * The returned segment has size {@code layout().byteSize()}
+     */
+    public static MemorySegment reinterpret(MemorySegment addr, Arena arena, Consumer<MemorySegment> cleanup) {
+        return reinterpret(addr, 1, arena, cleanup);
     }
-    public static MemorySegment ofAddress(MemorySegment addr, Arena scope) { return RuntimeHelper.asArray(addr, $LAYOUT(), 1, scope); }
-}
 
+    /**
+     * Reinterprets {@code addr} using target {@code arena} and {@code cleanupAction) (if any).
+     * The returned segment has size {@code elementCount * layout().byteSize()}
+     */
+    public static MemorySegment reinterpret(MemorySegment addr, long elementCount, Arena arena, Consumer<MemorySegment> cleanup) {
+        return addr.reinterpret(layout().byteSize() * elementCount, arena, cleanup);
+    }
+}
 
diff --git a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/fuse_file_info.java b/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/fuse_file_info.java
index 7252af4f..6e6e72b9 100644
--- a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/fuse_file_info.java
+++ b/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/fuse_file_info.java
@@ -2,174 +2,318 @@
 
 package org.cryptomator.jfuse.mac.extr.fuse;
 
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
+import java.lang.invoke.*;
 import java.lang.foreign.*;
+import java.nio.ByteOrder;
+import java.util.*;
+import java.util.function.*;
+import java.util.stream.*;
+
 import static java.lang.foreign.ValueLayout.*;
+import static java.lang.foreign.MemoryLayout.PathElement.*;
+
 /**
- * {@snippet :
+ * {@snippet lang=c :
  * struct fuse_file_info {
  *     int flags;
  *     unsigned long fh_old;
  *     int writepage;
- *      *     unsigned int direct_io;
- *     unsigned int keep_cache;
- *     unsigned int flush;
- *     unsigned int nonseekable;
- *     unsigned int flock_release;
- *     unsigned int padding;
+ *     unsigned int direct_io : 1;
+ *     unsigned int keep_cache : 1;
+ *     unsigned int flush : 1;
+ *     unsigned int nonseekable : 1;
+ *     unsigned int flock_release : 1;
+ *     unsigned int padding : 27;
  *     uint64_t fh;
  *     uint64_t lock_owner;
- * };
+ * }
  * }
  */
 public class fuse_file_info {
 
-    public static MemoryLayout $LAYOUT() {
-        return constants$0.const$4;
+    fuse_file_info() {
+        // Should not be called directly
+    }
+
+    private static final GroupLayout $LAYOUT = MemoryLayout.structLayout(
+        fuse_h.C_INT.withName("flags"),
+        MemoryLayout.paddingLayout(4),
+        fuse_h.C_LONG.withName("fh_old"),
+        fuse_h.C_INT.withName("writepage"),
+        MemoryLayout.paddingLayout(4),
+        fuse_h.C_LONG_LONG.withName("fh"),
+        fuse_h.C_LONG_LONG.withName("lock_owner")
+    ).withName("fuse_file_info");
+
+    /**
+     * The layout of this struct
+     */
+    public static final GroupLayout layout() {
+        return $LAYOUT;
+    }
+
+    private static final OfInt flags$LAYOUT = (OfInt)$LAYOUT.select(groupElement("flags"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int flags
+     * }
+     */
+    public static final OfInt flags$layout() {
+        return flags$LAYOUT;
     }
-    public static VarHandle flags$VH() {
-        return constants$0.const$5;
+
+    private static final long flags$OFFSET = 0;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int flags
+     * }
+     */
+    public static final long flags$offset() {
+        return flags$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int flags;
+     * {@snippet lang=c :
+     * int flags
      * }
      */
-    public static int flags$get(MemorySegment seg) {
-        return (int)constants$0.const$5.get(seg);
+    public static int flags(MemorySegment struct) {
+        return struct.get(flags$LAYOUT, flags$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int flags;
+     * {@snippet lang=c :
+     * int flags
      * }
      */
-    public static void flags$set(MemorySegment seg, int x) {
-        constants$0.const$5.set(seg, x);
-    }
-    public static int flags$get(MemorySegment seg, long index) {
-        return (int)constants$0.const$5.get(seg.asSlice(index*sizeof()));
+    public static void flags(MemorySegment struct, int fieldValue) {
+        struct.set(flags$LAYOUT, flags$OFFSET, fieldValue);
     }
-    public static void flags$set(MemorySegment seg, long index, int x) {
-        constants$0.const$5.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfLong fh_old$LAYOUT = (OfLong)$LAYOUT.select(groupElement("fh_old"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * unsigned long fh_old
+     * }
+     */
+    public static final OfLong fh_old$layout() {
+        return fh_old$LAYOUT;
     }
-    public static VarHandle fh_old$VH() {
-        return constants$1.const$0;
+
+    private static final long fh_old$OFFSET = 8;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * unsigned long fh_old
+     * }
+     */
+    public static final long fh_old$offset() {
+        return fh_old$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned long fh_old;
+     * {@snippet lang=c :
+     * unsigned long fh_old
      * }
      */
-    public static long fh_old$get(MemorySegment seg) {
-        return (long)constants$1.const$0.get(seg);
+    public static long fh_old(MemorySegment struct) {
+        return struct.get(fh_old$LAYOUT, fh_old$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned long fh_old;
+     * {@snippet lang=c :
+     * unsigned long fh_old
      * }
      */
-    public static void fh_old$set(MemorySegment seg, long x) {
-        constants$1.const$0.set(seg, x);
+    public static void fh_old(MemorySegment struct, long fieldValue) {
+        struct.set(fh_old$LAYOUT, fh_old$OFFSET, fieldValue);
     }
-    public static long fh_old$get(MemorySegment seg, long index) {
-        return (long)constants$1.const$0.get(seg.asSlice(index*sizeof()));
-    }
-    public static void fh_old$set(MemorySegment seg, long index, long x) {
-        constants$1.const$0.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt writepage$LAYOUT = (OfInt)$LAYOUT.select(groupElement("writepage"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int writepage
+     * }
+     */
+    public static final OfInt writepage$layout() {
+        return writepage$LAYOUT;
     }
-    public static VarHandle writepage$VH() {
-        return constants$1.const$1;
+
+    private static final long writepage$OFFSET = 16;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int writepage
+     * }
+     */
+    public static final long writepage$offset() {
+        return writepage$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int writepage;
+     * {@snippet lang=c :
+     * int writepage
      * }
      */
-    public static int writepage$get(MemorySegment seg) {
-        return (int)constants$1.const$1.get(seg);
+    public static int writepage(MemorySegment struct) {
+        return struct.get(writepage$LAYOUT, writepage$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int writepage;
+     * {@snippet lang=c :
+     * int writepage
      * }
      */
-    public static void writepage$set(MemorySegment seg, int x) {
-        constants$1.const$1.set(seg, x);
-    }
-    public static int writepage$get(MemorySegment seg, long index) {
-        return (int)constants$1.const$1.get(seg.asSlice(index*sizeof()));
+    public static void writepage(MemorySegment struct, int fieldValue) {
+        struct.set(writepage$LAYOUT, writepage$OFFSET, fieldValue);
     }
-    public static void writepage$set(MemorySegment seg, long index, int x) {
-        constants$1.const$1.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfLong fh$LAYOUT = (OfLong)$LAYOUT.select(groupElement("fh"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * uint64_t fh
+     * }
+     */
+    public static final OfLong fh$layout() {
+        return fh$LAYOUT;
     }
-    public static VarHandle fh$VH() {
-        return constants$1.const$2;
+
+    private static final long fh$OFFSET = 24;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * uint64_t fh
+     * }
+     */
+    public static final long fh$offset() {
+        return fh$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * uint64_t fh;
+     * {@snippet lang=c :
+     * uint64_t fh
      * }
      */
-    public static long fh$get(MemorySegment seg) {
-        return (long)constants$1.const$2.get(seg);
+    public static long fh(MemorySegment struct) {
+        return struct.get(fh$LAYOUT, fh$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * uint64_t fh;
+     * {@snippet lang=c :
+     * uint64_t fh
      * }
      */
-    public static void fh$set(MemorySegment seg, long x) {
-        constants$1.const$2.set(seg, x);
-    }
-    public static long fh$get(MemorySegment seg, long index) {
-        return (long)constants$1.const$2.get(seg.asSlice(index*sizeof()));
+    public static void fh(MemorySegment struct, long fieldValue) {
+        struct.set(fh$LAYOUT, fh$OFFSET, fieldValue);
     }
-    public static void fh$set(MemorySegment seg, long index, long x) {
-        constants$1.const$2.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfLong lock_owner$LAYOUT = (OfLong)$LAYOUT.select(groupElement("lock_owner"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * uint64_t lock_owner
+     * }
+     */
+    public static final OfLong lock_owner$layout() {
+        return lock_owner$LAYOUT;
     }
-    public static VarHandle lock_owner$VH() {
-        return constants$1.const$3;
+
+    private static final long lock_owner$OFFSET = 32;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * uint64_t lock_owner
+     * }
+     */
+    public static final long lock_owner$offset() {
+        return lock_owner$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * uint64_t lock_owner;
+     * {@snippet lang=c :
+     * uint64_t lock_owner
      * }
      */
-    public static long lock_owner$get(MemorySegment seg) {
-        return (long)constants$1.const$3.get(seg);
+    public static long lock_owner(MemorySegment struct) {
+        return struct.get(lock_owner$LAYOUT, lock_owner$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * uint64_t lock_owner;
+     * {@snippet lang=c :
+     * uint64_t lock_owner
      * }
      */
-    public static void lock_owner$set(MemorySegment seg, long x) {
-        constants$1.const$3.set(seg, x);
+    public static void lock_owner(MemorySegment struct, long fieldValue) {
+        struct.set(lock_owner$LAYOUT, lock_owner$OFFSET, fieldValue);
+    }
+
+    /**
+     * Obtains a slice of {@code arrayParam} which selects the array element at {@code index}.
+     * The returned segment has address {@code arrayParam.address() + index * layout().byteSize()}
+     */
+    public static MemorySegment asSlice(MemorySegment array, long index) {
+        return array.asSlice(layout().byteSize() * index);
+    }
+
+    /**
+     * The size (in bytes) of this struct
+     */
+    public static long sizeof() { return layout().byteSize(); }
+
+    /**
+     * Allocate a segment of size {@code layout().byteSize()} using {@code allocator}
+     */
+    public static MemorySegment allocate(SegmentAllocator allocator) {
+        return allocator.allocate(layout());
     }
-    public static long lock_owner$get(MemorySegment seg, long index) {
-        return (long)constants$1.const$3.get(seg.asSlice(index*sizeof()));
+
+    /**
+     * Allocate an array of size {@code elementCount} using {@code allocator}.
+     * The returned segment has size {@code elementCount * layout().byteSize()}.
+     */
+    public static MemorySegment allocateArray(long elementCount, SegmentAllocator allocator) {
+        return allocator.allocate(MemoryLayout.sequenceLayout(elementCount, layout()));
     }
-    public static void lock_owner$set(MemorySegment seg, long index, long x) {
-        constants$1.const$3.set(seg.asSlice(index*sizeof()), x);
+
+    /**
+     * Reinterprets {@code addr} using target {@code arena} and {@code cleanupAction) (if any).
+     * The returned segment has size {@code layout().byteSize()}
+     */
+    public static MemorySegment reinterpret(MemorySegment addr, Arena arena, Consumer<MemorySegment> cleanup) {
+        return reinterpret(addr, 1, arena, cleanup);
     }
-    public static long sizeof() { return $LAYOUT().byteSize(); }
-    public static MemorySegment allocate(SegmentAllocator allocator) { return allocator.allocate($LAYOUT()); }
-    public static MemorySegment allocateArray(long len, SegmentAllocator allocator) {
-        return allocator.allocate(MemoryLayout.sequenceLayout(len, $LAYOUT()));
+
+    /**
+     * Reinterprets {@code addr} using target {@code arena} and {@code cleanupAction) (if any).
+     * The returned segment has size {@code elementCount * layout().byteSize()}
+     */
+    public static MemorySegment reinterpret(MemorySegment addr, long elementCount, Arena arena, Consumer<MemorySegment> cleanup) {
+        return addr.reinterpret(layout().byteSize() * elementCount, arena, cleanup);
     }
-    public static MemorySegment ofAddress(MemorySegment addr, Arena scope) { return RuntimeHelper.asArray(addr, $LAYOUT(), 1, scope); }
 }
 
-
diff --git a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/fuse_fill_dir_t.java b/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/fuse_fill_dir_t.java
index be068f64..c86e6ad3 100644
--- a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/fuse_fill_dir_t.java
+++ b/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/fuse_fill_dir_t.java
@@ -2,32 +2,89 @@
 
 package org.cryptomator.jfuse.mac.extr.fuse;
 
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
+import java.lang.invoke.*;
 import java.lang.foreign.*;
+import java.nio.ByteOrder;
+import java.util.*;
+import java.util.function.*;
+import java.util.stream.*;
+
 import static java.lang.foreign.ValueLayout.*;
+import static java.lang.foreign.MemoryLayout.PathElement.*;
+
 /**
- * {@snippet :
- * int (*fuse_fill_dir_t)(void* buf,char* name,struct stat* stbuf,long long off);
+ * {@snippet lang=c :
+ * typedef int (*fuse_fill_dir_t)(void *, const char *, const struct stat {
+ *     dev_t st_dev;
+ *     mode_t st_mode;
+ *     nlink_t st_nlink;
+ *     __darwin_ino64_t st_ino;
+ *     uid_t st_uid;
+ *     gid_t st_gid;
+ *     dev_t st_rdev;
+ *     struct timespec st_atimespec;
+ *     struct timespec st_mtimespec;
+ *     struct timespec st_ctimespec;
+ *     struct timespec st_birthtimespec;
+ *     off_t st_size;
+ *     blkcnt_t st_blocks;
+ *     blksize_t st_blksize;
+ *     __uint32_t st_flags;
+ *     __uint32_t st_gen;
+ *     __int32_t st_lspare;
+ *     __int64_t st_qspare[2];
+ * } *, off_t)
  * }
  */
-public interface fuse_fill_dir_t {
+public class fuse_fill_dir_t {
 
-    int apply(java.lang.foreign.MemorySegment buf, java.lang.foreign.MemorySegment name, java.lang.foreign.MemorySegment stbuf, long off);
-    static MemorySegment allocate(fuse_fill_dir_t fi, Arena scope) {
-        return RuntimeHelper.upcallStub(constants$9.const$2, fi, constants$9.const$1, scope);
+    fuse_fill_dir_t() {
+        // Should not be called directly
     }
-    static fuse_fill_dir_t ofAddress(MemorySegment addr, Arena arena) {
-        MemorySegment symbol = addr.reinterpret(arena, null);
-        return (java.lang.foreign.MemorySegment _buf, java.lang.foreign.MemorySegment _name, java.lang.foreign.MemorySegment _stbuf, long _off) -> {
-            try {
-                return (int)constants$9.const$3.invokeExact(symbol, _buf, _name, _stbuf, _off);
-            } catch (Throwable ex$) {
-                throw new AssertionError("should not reach here", ex$);
-            }
-        };
+
+    /**
+     * The function pointer signature, expressed as a functional interface
+     */
+    public interface Function {
+        int apply(MemorySegment buf, MemorySegment name, MemorySegment stbuf, long off);
     }
-}
 
+    private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+        fuse_h.C_INT,
+        fuse_h.C_POINTER,
+        fuse_h.C_POINTER,
+        fuse_h.C_POINTER,
+        fuse_h.C_LONG_LONG
+    );
+
+    /**
+     * The descriptor of this function pointer
+     */
+    public static FunctionDescriptor descriptor() {
+        return $DESC;
+    }
+
+    private static final MethodHandle UP$MH = fuse_h.upcallHandle(fuse_fill_dir_t.Function.class, "apply", $DESC);
+
+    /**
+     * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+     * The lifetime of the returned segment is managed by {@code arena}
+     */
+    public static MemorySegment allocate(fuse_fill_dir_t.Function fi, Arena arena) {
+        return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+    }
+
+    private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+    /**
+     * Invoke the upcall stub {@code funcPtr}, with given parameters
+     */
+    public static int invoke(MemorySegment funcPtr,MemorySegment buf, MemorySegment name, MemorySegment stbuf, long off) {
+        try {
+            return (int) DOWN$MH.invokeExact(funcPtr, buf, name, stbuf, off);
+        } catch (Throwable ex$) {
+            throw new AssertionError("should not reach here", ex$);
+        }
+    }
+}
 
diff --git a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/fuse_h.java b/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/fuse_h.java
index 85ac08c4..d65651ef 100644
--- a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/fuse_h.java
+++ b/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/fuse_h.java
@@ -2,149 +2,453 @@
 
 package org.cryptomator.jfuse.mac.extr.fuse;
 
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
+import java.lang.invoke.*;
 import java.lang.foreign.*;
+import java.nio.ByteOrder;
+import java.util.*;
+import java.util.function.*;
+import java.util.stream.*;
+
 import static java.lang.foreign.ValueLayout.*;
-public class fuse_h  {
+import static java.lang.foreign.MemoryLayout.PathElement.*;
+
+public class fuse_h {
+
+    fuse_h() {
+        // Should not be called directly
+    }
+
+    static final Arena LIBRARY_ARENA = Arena.ofAuto();
+    static final boolean TRACE_DOWNCALLS = Boolean.getBoolean("jextract.trace.downcalls");
+
+    static void traceDowncall(String name, Object... args) {
+         String traceArgs = Arrays.stream(args)
+                       .map(Object::toString)
+                       .collect(Collectors.joining(", "));
+         System.out.printf("%s(%s)\n", name, traceArgs);
+    }
+
+    static MemorySegment findOrThrow(String symbol) {
+        return SYMBOL_LOOKUP.find(symbol)
+            .orElseThrow(() -> new UnsatisfiedLinkError("unresolved symbol: " + symbol));
+    }
+
+    static MethodHandle upcallHandle(Class<?> fi, String name, FunctionDescriptor fdesc) {
+        try {
+            return MethodHandles.lookup().findVirtual(fi, name, fdesc.toMethodType());
+        } catch (ReflectiveOperationException ex) {
+            throw new AssertionError(ex);
+        }
+    }
 
-    public static final OfByte C_CHAR = JAVA_BYTE;
-    public static final OfShort C_SHORT = JAVA_SHORT;
-    public static final OfInt C_INT = JAVA_INT;
-    public static final OfLong C_LONG = JAVA_LONG;
-    public static final OfLong C_LONG_LONG = JAVA_LONG;
-    public static final OfFloat C_FLOAT = JAVA_FLOAT;
-    public static final OfDouble C_DOUBLE = JAVA_DOUBLE;
-    public static final AddressLayout C_POINTER = RuntimeHelper.POINTER;
-    public static MethodHandle fuse_mount$MH() {
-        return RuntimeHelper.requireNonNull(constants$3.const$3,"fuse_mount");
+    static MemoryLayout align(MemoryLayout layout, long align) {
+        return switch (layout) {
+            case PaddingLayout p -> p;
+            case ValueLayout v -> v.withByteAlignment(align);
+            case GroupLayout g -> {
+                MemoryLayout[] alignedMembers = g.memberLayouts().stream()
+                        .map(m -> align(m, align)).toArray(MemoryLayout[]::new);
+                yield g instanceof StructLayout ?
+                        MemoryLayout.structLayout(alignedMembers) : MemoryLayout.unionLayout(alignedMembers);
+            }
+            case SequenceLayout s -> MemoryLayout.sequenceLayout(s.elementCount(), align(s.elementLayout(), align));
+        };
+    }
+
+    static final SymbolLookup SYMBOL_LOOKUP = SymbolLookup.loaderLookup()
+            .or(Linker.nativeLinker().defaultLookup());
+
+    public static final ValueLayout.OfBoolean C_BOOL = ValueLayout.JAVA_BOOLEAN;
+    public static final ValueLayout.OfByte C_CHAR = ValueLayout.JAVA_BYTE;
+    public static final ValueLayout.OfShort C_SHORT = ValueLayout.JAVA_SHORT;
+    public static final ValueLayout.OfInt C_INT = ValueLayout.JAVA_INT;
+    public static final ValueLayout.OfLong C_LONG_LONG = ValueLayout.JAVA_LONG;
+    public static final ValueLayout.OfFloat C_FLOAT = ValueLayout.JAVA_FLOAT;
+    public static final ValueLayout.OfDouble C_DOUBLE = ValueLayout.JAVA_DOUBLE;
+    public static final AddressLayout C_POINTER = ValueLayout.ADDRESS
+            .withTargetLayout(MemoryLayout.sequenceLayout(java.lang.Long.MAX_VALUE, JAVA_BYTE));
+    public static final ValueLayout.OfLong C_LONG = ValueLayout.JAVA_LONG;
+
+    private static class fuse_mount {
+        public static final FunctionDescriptor DESC = FunctionDescriptor.of(
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER
+        );
+
+        public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(
+                    fuse_h.findOrThrow("fuse_mount"),
+                    DESC);
+    }
+
+    /**
+     * Function descriptor for:
+     * {@snippet lang=c :
+     * struct fuse_chan *fuse_mount(const char *mountpoint, struct fuse_args *args)
+     * }
+     */
+    public static FunctionDescriptor fuse_mount$descriptor() {
+        return fuse_mount.DESC;
+    }
+
+    /**
+     * Downcall method handle for:
+     * {@snippet lang=c :
+     * struct fuse_chan *fuse_mount(const char *mountpoint, struct fuse_args *args)
+     * }
+     */
+    public static MethodHandle fuse_mount$handle() {
+        return fuse_mount.HANDLE;
     }
     /**
-     * {@snippet :
-     * struct fuse_chan* fuse_mount(char* mountpoint, struct fuse_args* args);
+     * {@snippet lang=c :
+     * struct fuse_chan *fuse_mount(const char *mountpoint, struct fuse_args *args)
      * }
      */
     public static MemorySegment fuse_mount(MemorySegment mountpoint, MemorySegment args) {
-        var mh$ = fuse_mount$MH();
+        var mh$ = fuse_mount.HANDLE;
         try {
-            return (java.lang.foreign.MemorySegment)mh$.invokeExact(mountpoint, args);
+            if (TRACE_DOWNCALLS) {
+                traceDowncall("fuse_mount", mountpoint, args);
+            }
+            return (MemorySegment)mh$.invokeExact(mountpoint, args);
         } catch (Throwable ex$) {
-            throw new AssertionError("should not reach here", ex$);
+           throw new AssertionError("should not reach here", ex$);
         }
     }
-    public static MethodHandle fuse_unmount$MH() {
-        return RuntimeHelper.requireNonNull(constants$3.const$5,"fuse_unmount");
+
+    private static class fuse_unmount {
+        public static final FunctionDescriptor DESC = FunctionDescriptor.ofVoid(
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER
+        );
+
+        public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(
+                    fuse_h.findOrThrow("fuse_unmount"),
+                    DESC);
     }
+
     /**
-     * {@snippet :
-     * void fuse_unmount(char* mountpoint, struct fuse_chan* ch);
+     * Function descriptor for:
+     * {@snippet lang=c :
+     * void fuse_unmount(const char *mountpoint, struct fuse_chan *ch)
+     * }
+     */
+    public static FunctionDescriptor fuse_unmount$descriptor() {
+        return fuse_unmount.DESC;
+    }
+
+    /**
+     * Downcall method handle for:
+     * {@snippet lang=c :
+     * void fuse_unmount(const char *mountpoint, struct fuse_chan *ch)
+     * }
+     */
+    public static MethodHandle fuse_unmount$handle() {
+        return fuse_unmount.HANDLE;
+    }
+    /**
+     * {@snippet lang=c :
+     * void fuse_unmount(const char *mountpoint, struct fuse_chan *ch)
      * }
      */
     public static void fuse_unmount(MemorySegment mountpoint, MemorySegment ch) {
-        var mh$ = fuse_unmount$MH();
+        var mh$ = fuse_unmount.HANDLE;
         try {
+            if (TRACE_DOWNCALLS) {
+                traceDowncall("fuse_unmount", mountpoint, ch);
+            }
             mh$.invokeExact(mountpoint, ch);
         } catch (Throwable ex$) {
-            throw new AssertionError("should not reach here", ex$);
+           throw new AssertionError("should not reach here", ex$);
         }
     }
-    public static MethodHandle fuse_parse_cmdline$MH() {
-        return RuntimeHelper.requireNonNull(constants$4.const$1,"fuse_parse_cmdline");
+
+    private static class fuse_parse_cmdline {
+        public static final FunctionDescriptor DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER
+        );
+
+        public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(
+                    fuse_h.findOrThrow("fuse_parse_cmdline"),
+                    DESC);
+    }
+
+    /**
+     * Function descriptor for:
+     * {@snippet lang=c :
+     * int fuse_parse_cmdline(struct fuse_args *args, char **mountpoint, int *multithreaded, int *foreground)
+     * }
+     */
+    public static FunctionDescriptor fuse_parse_cmdline$descriptor() {
+        return fuse_parse_cmdline.DESC;
+    }
+
+    /**
+     * Downcall method handle for:
+     * {@snippet lang=c :
+     * int fuse_parse_cmdline(struct fuse_args *args, char **mountpoint, int *multithreaded, int *foreground)
+     * }
+     */
+    public static MethodHandle fuse_parse_cmdline$handle() {
+        return fuse_parse_cmdline.HANDLE;
     }
     /**
-     * {@snippet :
-     * int fuse_parse_cmdline(struct fuse_args* args, char** mountpoint, int* multithreaded, int* foreground);
+     * {@snippet lang=c :
+     * int fuse_parse_cmdline(struct fuse_args *args, char **mountpoint, int *multithreaded, int *foreground)
      * }
      */
     public static int fuse_parse_cmdline(MemorySegment args, MemorySegment mountpoint, MemorySegment multithreaded, MemorySegment foreground) {
-        var mh$ = fuse_parse_cmdline$MH();
+        var mh$ = fuse_parse_cmdline.HANDLE;
         try {
+            if (TRACE_DOWNCALLS) {
+                traceDowncall("fuse_parse_cmdline", args, mountpoint, multithreaded, foreground);
+            }
             return (int)mh$.invokeExact(args, mountpoint, multithreaded, foreground);
         } catch (Throwable ex$) {
-            throw new AssertionError("should not reach here", ex$);
+           throw new AssertionError("should not reach here", ex$);
         }
     }
-    public static MethodHandle fuse_new$MH() {
-        return RuntimeHelper.requireNonNull(constants$32.const$1,"fuse_new");
+
+    private static class fuse_new {
+        public static final FunctionDescriptor DESC = FunctionDescriptor.of(
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER,
+            fuse_h.C_LONG,
+            fuse_h.C_POINTER
+        );
+
+        public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(
+                    fuse_h.findOrThrow("fuse_new"),
+                    DESC);
     }
+
     /**
-     * {@snippet :
-     * struct fuse* fuse_new(struct fuse_chan* ch, struct fuse_args* args, struct fuse_operations* op, size_t op_size, void* user_data);
+     * Function descriptor for:
+     * {@snippet lang=c :
+     * struct fuse *fuse_new(struct fuse_chan *ch, struct fuse_args *args, const struct fuse_operations *op, size_t op_size, void *user_data)
+     * }
+     */
+    public static FunctionDescriptor fuse_new$descriptor() {
+        return fuse_new.DESC;
+    }
+
+    /**
+     * Downcall method handle for:
+     * {@snippet lang=c :
+     * struct fuse *fuse_new(struct fuse_chan *ch, struct fuse_args *args, const struct fuse_operations *op, size_t op_size, void *user_data)
+     * }
+     */
+    public static MethodHandle fuse_new$handle() {
+        return fuse_new.HANDLE;
+    }
+    /**
+     * {@snippet lang=c :
+     * struct fuse *fuse_new(struct fuse_chan *ch, struct fuse_args *args, const struct fuse_operations *op, size_t op_size, void *user_data)
      * }
      */
     public static MemorySegment fuse_new(MemorySegment ch, MemorySegment args, MemorySegment op, long op_size, MemorySegment user_data) {
-        var mh$ = fuse_new$MH();
+        var mh$ = fuse_new.HANDLE;
         try {
-            return (java.lang.foreign.MemorySegment)mh$.invokeExact(ch, args, op, op_size, user_data);
+            if (TRACE_DOWNCALLS) {
+                traceDowncall("fuse_new", ch, args, op, op_size, user_data);
+            }
+            return (MemorySegment)mh$.invokeExact(ch, args, op, op_size, user_data);
         } catch (Throwable ex$) {
-            throw new AssertionError("should not reach here", ex$);
+           throw new AssertionError("should not reach here", ex$);
         }
     }
-    public static MethodHandle fuse_destroy$MH() {
-        return RuntimeHelper.requireNonNull(constants$32.const$2,"fuse_destroy");
+
+    private static class fuse_destroy {
+        public static final FunctionDescriptor DESC = FunctionDescriptor.ofVoid(
+            fuse_h.C_POINTER
+        );
+
+        public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(
+                    fuse_h.findOrThrow("fuse_destroy"),
+                    DESC);
     }
+
     /**
-     * {@snippet :
-     * void fuse_destroy(struct fuse* f);
+     * Function descriptor for:
+     * {@snippet lang=c :
+     * void fuse_destroy(struct fuse *f)
+     * }
+     */
+    public static FunctionDescriptor fuse_destroy$descriptor() {
+        return fuse_destroy.DESC;
+    }
+
+    /**
+     * Downcall method handle for:
+     * {@snippet lang=c :
+     * void fuse_destroy(struct fuse *f)
+     * }
+     */
+    public static MethodHandle fuse_destroy$handle() {
+        return fuse_destroy.HANDLE;
+    }
+    /**
+     * {@snippet lang=c :
+     * void fuse_destroy(struct fuse *f)
      * }
      */
     public static void fuse_destroy(MemorySegment f) {
-        var mh$ = fuse_destroy$MH();
+        var mh$ = fuse_destroy.HANDLE;
         try {
+            if (TRACE_DOWNCALLS) {
+                traceDowncall("fuse_destroy", f);
+            }
             mh$.invokeExact(f);
         } catch (Throwable ex$) {
-            throw new AssertionError("should not reach here", ex$);
+           throw new AssertionError("should not reach here", ex$);
         }
     }
-    public static MethodHandle fuse_loop$MH() {
-        return RuntimeHelper.requireNonNull(constants$32.const$3,"fuse_loop");
+
+    private static class fuse_loop {
+        public static final FunctionDescriptor DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER
+        );
+
+        public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(
+                    fuse_h.findOrThrow("fuse_loop"),
+                    DESC);
+    }
+
+    /**
+     * Function descriptor for:
+     * {@snippet lang=c :
+     * int fuse_loop(struct fuse *f)
+     * }
+     */
+    public static FunctionDescriptor fuse_loop$descriptor() {
+        return fuse_loop.DESC;
     }
+
     /**
-     * {@snippet :
-     * int fuse_loop(struct fuse* f);
+     * Downcall method handle for:
+     * {@snippet lang=c :
+     * int fuse_loop(struct fuse *f)
+     * }
+     */
+    public static MethodHandle fuse_loop$handle() {
+        return fuse_loop.HANDLE;
+    }
+    /**
+     * {@snippet lang=c :
+     * int fuse_loop(struct fuse *f)
      * }
      */
     public static int fuse_loop(MemorySegment f) {
-        var mh$ = fuse_loop$MH();
+        var mh$ = fuse_loop.HANDLE;
         try {
+            if (TRACE_DOWNCALLS) {
+                traceDowncall("fuse_loop", f);
+            }
             return (int)mh$.invokeExact(f);
         } catch (Throwable ex$) {
-            throw new AssertionError("should not reach here", ex$);
+           throw new AssertionError("should not reach here", ex$);
         }
     }
-    public static MethodHandle fuse_exit$MH() {
-        return RuntimeHelper.requireNonNull(constants$32.const$4,"fuse_exit");
+
+    private static class fuse_exit {
+        public static final FunctionDescriptor DESC = FunctionDescriptor.ofVoid(
+            fuse_h.C_POINTER
+        );
+
+        public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(
+                    fuse_h.findOrThrow("fuse_exit"),
+                    DESC);
+    }
+
+    /**
+     * Function descriptor for:
+     * {@snippet lang=c :
+     * void fuse_exit(struct fuse *f)
+     * }
+     */
+    public static FunctionDescriptor fuse_exit$descriptor() {
+        return fuse_exit.DESC;
+    }
+
+    /**
+     * Downcall method handle for:
+     * {@snippet lang=c :
+     * void fuse_exit(struct fuse *f)
+     * }
+     */
+    public static MethodHandle fuse_exit$handle() {
+        return fuse_exit.HANDLE;
     }
     /**
-     * {@snippet :
-     * void fuse_exit(struct fuse* f);
+     * {@snippet lang=c :
+     * void fuse_exit(struct fuse *f)
      * }
      */
     public static void fuse_exit(MemorySegment f) {
-        var mh$ = fuse_exit$MH();
+        var mh$ = fuse_exit.HANDLE;
         try {
+            if (TRACE_DOWNCALLS) {
+                traceDowncall("fuse_exit", f);
+            }
             mh$.invokeExact(f);
         } catch (Throwable ex$) {
-            throw new AssertionError("should not reach here", ex$);
+           throw new AssertionError("should not reach here", ex$);
         }
     }
-    public static MethodHandle fuse_loop_mt$MH() {
-        return RuntimeHelper.requireNonNull(constants$32.const$5,"fuse_loop_mt");
+
+    private static class fuse_loop_mt {
+        public static final FunctionDescriptor DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER
+        );
+
+        public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(
+                    fuse_h.findOrThrow("fuse_loop_mt"),
+                    DESC);
+    }
+
+    /**
+     * Function descriptor for:
+     * {@snippet lang=c :
+     * int fuse_loop_mt(struct fuse *f)
+     * }
+     */
+    public static FunctionDescriptor fuse_loop_mt$descriptor() {
+        return fuse_loop_mt.DESC;
+    }
+
+    /**
+     * Downcall method handle for:
+     * {@snippet lang=c :
+     * int fuse_loop_mt(struct fuse *f)
+     * }
+     */
+    public static MethodHandle fuse_loop_mt$handle() {
+        return fuse_loop_mt.HANDLE;
     }
     /**
-     * {@snippet :
-     * int fuse_loop_mt(struct fuse* f);
+     * {@snippet lang=c :
+     * int fuse_loop_mt(struct fuse *f)
      * }
      */
     public static int fuse_loop_mt(MemorySegment f) {
-        var mh$ = fuse_loop_mt$MH();
+        var mh$ = fuse_loop_mt.HANDLE;
         try {
+            if (TRACE_DOWNCALLS) {
+                traceDowncall("fuse_loop_mt", f);
+            }
             return (int)mh$.invokeExact(f);
         } catch (Throwable ex$) {
-            throw new AssertionError("should not reach here", ex$);
+           throw new AssertionError("should not reach here", ex$);
         }
     }
 }
 
-
diff --git a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/fuse_operations.java b/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/fuse_operations.java
index 999ba4ec..a282e5ee 100644
--- a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/fuse_operations.java
+++ b/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/fuse_operations.java
@@ -2,2408 +2,4566 @@
 
 package org.cryptomator.jfuse.mac.extr.fuse;
 
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
+import java.lang.invoke.*;
 import java.lang.foreign.*;
+import java.nio.ByteOrder;
+import java.util.*;
+import java.util.function.*;
+import java.util.stream.*;
+
 import static java.lang.foreign.ValueLayout.*;
+import static java.lang.foreign.MemoryLayout.PathElement.*;
+
 /**
- * {@snippet :
+ * {@snippet lang=c :
  * struct fuse_operations {
- *     int (*getattr)(char*,struct stat*);
- *     int (*readlink)(char*,char*,size_t);
- *     int (*getdir)(char*,fuse_dirh_t,fuse_dirfil_t);
- *     int (*mknod)(char*,mode_t,dev_t);
- *     int (*mkdir)(char*,mode_t);
- *     int (*unlink)(char*);
- *     int (*rmdir)(char*);
- *     int (*symlink)(char*,char*);
- *     int (*rename)(char*,char*);
- *     int (*link)(char*,char*);
- *     int (*chmod)(char*,mode_t);
- *     int (*chown)(char*,uid_t,gid_t);
- *     int (*truncate)(char*,off_t);
- *     int (*utime)(char*,struct utimbuf*);
- *     int (*open)(char*,struct fuse_file_info*);
- *     int (*read)(char*,char*,size_t,off_t,struct fuse_file_info*);
- *     int (*write)(char*,char*,size_t,off_t,struct fuse_file_info*);
- *     int (*statfs)(char*,struct statvfs*);
- *     int (*flush)(char*,struct fuse_file_info*);
- *     int (*release)(char*,struct fuse_file_info*);
- *     int (*fsync)(char*,int,struct fuse_file_info*);
- *     int (*setxattr)(char*,char*,char*,size_t,int);
- *     int (*getxattr)(char*,char*,char*,size_t);
- *     int (*listxattr)(char*,char*,size_t);
- *     int (*removexattr)(char*,char*);
- *     int (*opendir)(char*,struct fuse_file_info*);
- *     int (*readdir)(char*,void*,fuse_fill_dir_t,off_t,struct fuse_file_info*);
- *     int (*releasedir)(char*,struct fuse_file_info*);
- *     int (*fsyncdir)(char*,int,struct fuse_file_info*);
- *     void* (*init)(struct fuse_conn_info*);
- *     void (*destroy)(void*);
- *     int (*access)(char*,int);
- *     int (*create)(char*,mode_t,struct fuse_file_info*);
- *     int (*ftruncate)(char*,off_t,struct fuse_file_info*);
- *     int (*fgetattr)(char*,struct stat*,struct fuse_file_info*);
- *     int (*lock)(char*,struct fuse_file_info*,int,struct flock*);
- *     int (*utimens)(char*,struct timespec*);
- *     int (*bmap)(char*,size_t,uint64_t*);
- *      *     unsigned int flag_nullpath_ok;
- *     unsigned int flag_nopath;
- *     unsigned int flag_utime_omit_ok;
- *     unsigned int flag_reserved;
- *     int (*ioctl)(char*,int,void*,struct fuse_file_info*,unsigned int,void*);
- *     int (*poll)(char*,struct fuse_file_info*,struct fuse_pollhandle*,unsigned int*);
- *     int (*write_buf)(char*,struct fuse_bufvec*,off_t,struct fuse_file_info*);
- *     int (*read_buf)(char*,struct fuse_bufvec**,size_t,off_t,struct fuse_file_info*);
- *     int (*flock)(char*,struct fuse_file_info*,int);
- *     int (*fallocate)(char*,int,off_t,off_t,struct fuse_file_info*);
- * };
+ *     int (*getattr)(const char *, struct stat *);
+ *     int (*readlink)(const char *, char *, size_t);
+ *     int (*getdir)(const char *, fuse_dirh_t, fuse_dirfil_t);
+ *     int (*mknod)(const char *, mode_t, dev_t);
+ *     int (*mkdir)(const char *, mode_t);
+ *     int (*unlink)(const char *);
+ *     int (*rmdir)(const char *);
+ *     int (*symlink)(const char *, const char *);
+ *     int (*rename)(const char *, const char *);
+ *     int (*link)(const char *, const char *);
+ *     int (*chmod)(const char *, mode_t);
+ *     int (*chown)(const char *, uid_t, gid_t);
+ *     int (*truncate)(const char *, off_t);
+ *     int (*utime)(const char *, struct utimbuf *);
+ *     int (*open)(const char *, struct fuse_file_info *);
+ *     int (*read)(const char *, char *, size_t, off_t, struct fuse_file_info *);
+ *     int (*write)(const char *, const char *, size_t, off_t, struct fuse_file_info *);
+ *     int (*statfs)(const char *, struct statvfs *);
+ *     int (*flush)(const char *, struct fuse_file_info *);
+ *     int (*release)(const char *, struct fuse_file_info *);
+ *     int (*fsync)(const char *, int, struct fuse_file_info *);
+ *     int (*setxattr)(const char *, const char *, const char *, size_t, int);
+ *     int (*getxattr)(const char *, const char *, char *, size_t);
+ *     int (*listxattr)(const char *, char *, size_t);
+ *     int (*removexattr)(const char *, const char *);
+ *     int (*opendir)(const char *, struct fuse_file_info *);
+ *     int (*readdir)(const char *, void *, fuse_fill_dir_t, off_t, struct fuse_file_info *);
+ *     int (*releasedir)(const char *, struct fuse_file_info *);
+ *     int (*fsyncdir)(const char *, int, struct fuse_file_info *);
+ *     void *(*init)(struct fuse_conn_info *);
+ *     void (*destroy)(void *);
+ *     int (*access)(const char *, int);
+ *     int (*create)(const char *, mode_t, struct fuse_file_info *);
+ *     int (*ftruncate)(const char *, off_t, struct fuse_file_info *);
+ *     int (*fgetattr)(const char *, struct stat *, struct fuse_file_info *);
+ *     int (*lock)(const char *, struct fuse_file_info *, int, struct flock *);
+ *     int (*utimens)(const char *, const struct timespec *);
+ *     int (*bmap)(const char *, size_t, uint64_t *);
+ *     unsigned int flag_nullpath_ok : 1;
+ *     unsigned int flag_nopath : 1;
+ *     unsigned int flag_utime_omit_ok : 1;
+ *     unsigned int flag_reserved : 29;
+ *     int (*ioctl)(const char *, int, void *, struct fuse_file_info *, unsigned int, void *);
+ *     int (*poll)(const char *, struct fuse_file_info *, struct fuse_pollhandle *, unsigned int *);
+ *     int (*write_buf)(const char *, struct fuse_bufvec *, off_t, struct fuse_file_info *);
+ *     int (*read_buf)(const char *, struct fuse_bufvec **, size_t, off_t, struct fuse_file_info *);
+ *     int (*flock)(const char *, struct fuse_file_info *, int);
+ *     int (*fallocate)(const char *, int, off_t, off_t, struct fuse_file_info *);
+ * }
  * }
  */
 public class fuse_operations {
 
-    public static MemoryLayout $LAYOUT() {
-        return constants$9.const$4;
+    fuse_operations() {
+        // Should not be called directly
     }
+
+    private static final GroupLayout $LAYOUT = MemoryLayout.structLayout(
+        fuse_h.C_POINTER.withName("getattr"),
+        fuse_h.C_POINTER.withName("readlink"),
+        fuse_h.C_POINTER.withName("getdir"),
+        fuse_h.C_POINTER.withName("mknod"),
+        fuse_h.C_POINTER.withName("mkdir"),
+        fuse_h.C_POINTER.withName("unlink"),
+        fuse_h.C_POINTER.withName("rmdir"),
+        fuse_h.C_POINTER.withName("symlink"),
+        fuse_h.C_POINTER.withName("rename"),
+        fuse_h.C_POINTER.withName("link"),
+        fuse_h.C_POINTER.withName("chmod"),
+        fuse_h.C_POINTER.withName("chown"),
+        fuse_h.C_POINTER.withName("truncate"),
+        fuse_h.C_POINTER.withName("utime"),
+        fuse_h.C_POINTER.withName("open"),
+        fuse_h.C_POINTER.withName("read"),
+        fuse_h.C_POINTER.withName("write"),
+        fuse_h.C_POINTER.withName("statfs"),
+        fuse_h.C_POINTER.withName("flush"),
+        fuse_h.C_POINTER.withName("release"),
+        fuse_h.C_POINTER.withName("fsync"),
+        fuse_h.C_POINTER.withName("setxattr"),
+        fuse_h.C_POINTER.withName("getxattr"),
+        fuse_h.C_POINTER.withName("listxattr"),
+        fuse_h.C_POINTER.withName("removexattr"),
+        fuse_h.C_POINTER.withName("opendir"),
+        fuse_h.C_POINTER.withName("readdir"),
+        fuse_h.C_POINTER.withName("releasedir"),
+        fuse_h.C_POINTER.withName("fsyncdir"),
+        fuse_h.C_POINTER.withName("init"),
+        fuse_h.C_POINTER.withName("destroy"),
+        fuse_h.C_POINTER.withName("access"),
+        fuse_h.C_POINTER.withName("create"),
+        fuse_h.C_POINTER.withName("ftruncate"),
+        fuse_h.C_POINTER.withName("fgetattr"),
+        fuse_h.C_POINTER.withName("lock"),
+        fuse_h.C_POINTER.withName("utimens"),
+        fuse_h.C_POINTER.withName("bmap"),
+        MemoryLayout.paddingLayout(8),
+        fuse_h.C_POINTER.withName("ioctl"),
+        fuse_h.C_POINTER.withName("poll"),
+        fuse_h.C_POINTER.withName("write_buf"),
+        fuse_h.C_POINTER.withName("read_buf"),
+        fuse_h.C_POINTER.withName("flock"),
+        fuse_h.C_POINTER.withName("fallocate")
+    ).withName("fuse_operations");
+
     /**
-     * {@snippet :
- * int (*getattr)(char*,struct stat*);
-     * }
+     * The layout of this struct
      */
-    public interface getattr {
-
-        int apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1);
-        static MemorySegment allocate(getattr fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$10.const$0, fi, constants$9.const$5, scope);
-        }
-        static getattr ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1) -> {
-                try {
-                    return (int)constants$10.const$1.invokeExact(symbol, __x0, __x1);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
-        }
+    public static final GroupLayout layout() {
+        return $LAYOUT;
     }
 
-    public static VarHandle getattr$VH() {
-        return constants$10.const$2;
-    }
     /**
-     * Getter for field:
-     * {@snippet :
-     * int (*getattr)(char*,struct stat*);
+     * {@snippet lang=c :
+     * int (*getattr)(const char *, struct stat *)
      * }
      */
-    public static MemorySegment getattr$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$10.const$2.get(seg);
+    public static class getattr {
+
+        getattr() {
+            // Should not be called directly
+        }
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, MemorySegment _x1);
+        }
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(getattr.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(getattr.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
     }
+
+    private static final AddressLayout getattr$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("getattr"));
+
     /**
-     * Setter for field:
-     * {@snippet :
-     * int (*getattr)(char*,struct stat*);
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*getattr)(const char *, struct stat *)
      * }
      */
-    public static void getattr$set(MemorySegment seg, MemorySegment x) {
-        constants$10.const$2.set(seg, x);
-    }
-    public static MemorySegment getattr$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$10.const$2.get(seg.asSlice(index*sizeof()));
-    }
-    public static void getattr$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$10.const$2.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static getattr getattr(MemorySegment segment, Arena scope) {
-        return getattr.ofAddress(getattr$get(segment), scope);
+    public static final AddressLayout getattr$layout() {
+        return getattr$LAYOUT;
     }
+
+    private static final long getattr$OFFSET = 0;
+
     /**
-     * {@snippet :
- * int (*readlink)(char*,char*,size_t);
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*getattr)(const char *, struct stat *)
      * }
      */
-    public interface readlink {
-
-        int apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1, long _x2);
-        static MemorySegment allocate(readlink fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$10.const$4, fi, constants$10.const$3, scope);
-        }
-        static readlink ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1, long __x2) -> {
-                try {
-                    return (int)constants$10.const$5.invokeExact(symbol, __x0, __x1, __x2);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
-        }
+    public static final long getattr$offset() {
+        return getattr$OFFSET;
     }
 
-    public static VarHandle readlink$VH() {
-        return constants$11.const$0;
-    }
     /**
      * Getter for field:
-     * {@snippet :
-     * int (*readlink)(char*,char*,size_t);
+     * {@snippet lang=c :
+     * int (*getattr)(const char *, struct stat *)
      * }
      */
-    public static MemorySegment readlink$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$11.const$0.get(seg);
+    public static MemorySegment getattr(MemorySegment struct) {
+        return struct.get(getattr$LAYOUT, getattr$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int (*readlink)(char*,char*,size_t);
+     * {@snippet lang=c :
+     * int (*getattr)(const char *, struct stat *)
      * }
      */
-    public static void readlink$set(MemorySegment seg, MemorySegment x) {
-        constants$11.const$0.set(seg, x);
-    }
-    public static MemorySegment readlink$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$11.const$0.get(seg.asSlice(index*sizeof()));
-    }
-    public static void readlink$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$11.const$0.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static readlink readlink(MemorySegment segment, Arena scope) {
-        return readlink.ofAddress(readlink$get(segment), scope);
+    public static void getattr(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(getattr$LAYOUT, getattr$OFFSET, fieldValue);
     }
+
     /**
-     * {@snippet :
- * int (*getdir)(char*,fuse_dirh_t,fuse_dirfil_t);
+     * {@snippet lang=c :
+     * int (*readlink)(const char *, char *, size_t)
      * }
      */
-    public interface getdir {
+    public static class readlink {
 
-        int apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1, java.lang.foreign.MemorySegment _x2);
-        static MemorySegment allocate(getdir fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$11.const$2, fi, constants$11.const$1, scope);
+        readlink() {
+            // Should not be called directly
         }
-        static getdir ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1, java.lang.foreign.MemorySegment __x2) -> {
-                try {
-                    return (int)constants$11.const$3.invokeExact(symbol, __x0, __x1, __x2);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, MemorySegment _x1, long _x2);
         }
-    }
 
-    public static VarHandle getdir$VH() {
-        return constants$11.const$4;
-    }
-    /**
-     * Getter for field:
-     * {@snippet :
-     * int (*getdir)(char*,fuse_dirh_t,fuse_dirfil_t);
-     * }
-     */
-    public static MemorySegment getdir$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$11.const$4.get(seg);
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER,
+            fuse_h.C_LONG
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(readlink.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(readlink.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1, long _x2) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
     }
+
+    private static final AddressLayout readlink$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("readlink"));
+
     /**
-     * Setter for field:
-     * {@snippet :
-     * int (*getdir)(char*,fuse_dirh_t,fuse_dirfil_t);
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*readlink)(const char *, char *, size_t)
      * }
      */
-    public static void getdir$set(MemorySegment seg, MemorySegment x) {
-        constants$11.const$4.set(seg, x);
-    }
-    public static MemorySegment getdir$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$11.const$4.get(seg.asSlice(index*sizeof()));
-    }
-    public static void getdir$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$11.const$4.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static getdir getdir(MemorySegment segment, Arena scope) {
-        return getdir.ofAddress(getdir$get(segment), scope);
+    public static final AddressLayout readlink$layout() {
+        return readlink$LAYOUT;
     }
+
+    private static final long readlink$OFFSET = 8;
+
     /**
-     * {@snippet :
- * int (*mknod)(char*,mode_t,dev_t);
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*readlink)(const char *, char *, size_t)
      * }
      */
-    public interface mknod {
-
-        int apply(java.lang.foreign.MemorySegment _x0, short _x1, int _x2);
-        static MemorySegment allocate(mknod fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$12.const$0, fi, constants$11.const$5, scope);
-        }
-        static mknod ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, short __x1, int __x2) -> {
-                try {
-                    return (int)constants$12.const$1.invokeExact(symbol, __x0, __x1, __x2);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
-        }
+    public static final long readlink$offset() {
+        return readlink$OFFSET;
     }
 
-    public static VarHandle mknod$VH() {
-        return constants$12.const$2;
-    }
     /**
      * Getter for field:
-     * {@snippet :
-     * int (*mknod)(char*,mode_t,dev_t);
+     * {@snippet lang=c :
+     * int (*readlink)(const char *, char *, size_t)
      * }
      */
-    public static MemorySegment mknod$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$12.const$2.get(seg);
+    public static MemorySegment readlink(MemorySegment struct) {
+        return struct.get(readlink$LAYOUT, readlink$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int (*mknod)(char*,mode_t,dev_t);
+     * {@snippet lang=c :
+     * int (*readlink)(const char *, char *, size_t)
      * }
      */
-    public static void mknod$set(MemorySegment seg, MemorySegment x) {
-        constants$12.const$2.set(seg, x);
-    }
-    public static MemorySegment mknod$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$12.const$2.get(seg.asSlice(index*sizeof()));
-    }
-    public static void mknod$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$12.const$2.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static mknod mknod(MemorySegment segment, Arena scope) {
-        return mknod.ofAddress(mknod$get(segment), scope);
+    public static void readlink(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(readlink$LAYOUT, readlink$OFFSET, fieldValue);
     }
+
     /**
-     * {@snippet :
- * int (*mkdir)(char*,mode_t);
+     * {@snippet lang=c :
+     * int (*getdir)(const char *, fuse_dirh_t, fuse_dirfil_t)
      * }
      */
-    public interface mkdir {
+    public static class getdir {
 
-        int apply(java.lang.foreign.MemorySegment _x0, short _x1);
-        static MemorySegment allocate(mkdir fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$12.const$4, fi, constants$12.const$3, scope);
+        getdir() {
+            // Should not be called directly
         }
-        static mkdir ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, short __x1) -> {
-                try {
-                    return (int)constants$12.const$5.invokeExact(symbol, __x0, __x1);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, MemorySegment _x1, MemorySegment _x2);
         }
-    }
 
-    public static VarHandle mkdir$VH() {
-        return constants$13.const$0;
-    }
-    /**
-     * Getter for field:
-     * {@snippet :
-     * int (*mkdir)(char*,mode_t);
-     * }
-     */
-    public static MemorySegment mkdir$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$13.const$0.get(seg);
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(getdir.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(getdir.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1, MemorySegment _x2) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
     }
+
+    private static final AddressLayout getdir$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("getdir"));
+
     /**
-     * Setter for field:
-     * {@snippet :
-     * int (*mkdir)(char*,mode_t);
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*getdir)(const char *, fuse_dirh_t, fuse_dirfil_t)
      * }
      */
-    public static void mkdir$set(MemorySegment seg, MemorySegment x) {
-        constants$13.const$0.set(seg, x);
-    }
-    public static MemorySegment mkdir$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$13.const$0.get(seg.asSlice(index*sizeof()));
-    }
-    public static void mkdir$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$13.const$0.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static mkdir mkdir(MemorySegment segment, Arena scope) {
-        return mkdir.ofAddress(mkdir$get(segment), scope);
+    public static final AddressLayout getdir$layout() {
+        return getdir$LAYOUT;
     }
+
+    private static final long getdir$OFFSET = 16;
+
     /**
-     * {@snippet :
- * int (*unlink)(char*);
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*getdir)(const char *, fuse_dirh_t, fuse_dirfil_t)
      * }
      */
-    public interface unlink {
-
-        int apply(java.lang.foreign.MemorySegment _x0);
-        static MemorySegment allocate(unlink fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$13.const$2, fi, constants$13.const$1, scope);
-        }
-        static unlink ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0) -> {
-                try {
-                    return (int)constants$13.const$3.invokeExact(symbol, __x0);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
-        }
+    public static final long getdir$offset() {
+        return getdir$OFFSET;
     }
 
-    public static VarHandle unlink$VH() {
-        return constants$13.const$4;
-    }
     /**
      * Getter for field:
-     * {@snippet :
-     * int (*unlink)(char*);
+     * {@snippet lang=c :
+     * int (*getdir)(const char *, fuse_dirh_t, fuse_dirfil_t)
      * }
      */
-    public static MemorySegment unlink$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$13.const$4.get(seg);
+    public static MemorySegment getdir(MemorySegment struct) {
+        return struct.get(getdir$LAYOUT, getdir$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int (*unlink)(char*);
+     * {@snippet lang=c :
+     * int (*getdir)(const char *, fuse_dirh_t, fuse_dirfil_t)
      * }
      */
-    public static void unlink$set(MemorySegment seg, MemorySegment x) {
-        constants$13.const$4.set(seg, x);
-    }
-    public static MemorySegment unlink$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$13.const$4.get(seg.asSlice(index*sizeof()));
-    }
-    public static void unlink$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$13.const$4.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static unlink unlink(MemorySegment segment, Arena scope) {
-        return unlink.ofAddress(unlink$get(segment), scope);
+    public static void getdir(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(getdir$LAYOUT, getdir$OFFSET, fieldValue);
     }
+
     /**
-     * {@snippet :
- * int (*rmdir)(char*);
+     * {@snippet lang=c :
+     * int (*mknod)(const char *, mode_t, dev_t)
      * }
      */
-    public interface rmdir {
+    public static class mknod {
 
-        int apply(java.lang.foreign.MemorySegment _x0);
-        static MemorySegment allocate(rmdir fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$13.const$5, fi, constants$13.const$1, scope);
+        mknod() {
+            // Should not be called directly
         }
-        static rmdir ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0) -> {
-                try {
-                    return (int)constants$13.const$3.invokeExact(symbol, __x0);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, short _x1, int _x2);
         }
-    }
 
-    public static VarHandle rmdir$VH() {
-        return constants$14.const$0;
-    }
-    /**
-     * Getter for field:
-     * {@snippet :
-     * int (*rmdir)(char*);
-     * }
-     */
-    public static MemorySegment rmdir$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$14.const$0.get(seg);
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_SHORT,
+            fuse_h.C_INT
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(mknod.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(mknod.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, short _x1, int _x2) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
     }
+
+    private static final AddressLayout mknod$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("mknod"));
+
     /**
-     * Setter for field:
-     * {@snippet :
-     * int (*rmdir)(char*);
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*mknod)(const char *, mode_t, dev_t)
      * }
      */
-    public static void rmdir$set(MemorySegment seg, MemorySegment x) {
-        constants$14.const$0.set(seg, x);
-    }
-    public static MemorySegment rmdir$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$14.const$0.get(seg.asSlice(index*sizeof()));
-    }
-    public static void rmdir$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$14.const$0.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static rmdir rmdir(MemorySegment segment, Arena scope) {
-        return rmdir.ofAddress(rmdir$get(segment), scope);
+    public static final AddressLayout mknod$layout() {
+        return mknod$LAYOUT;
     }
+
+    private static final long mknod$OFFSET = 24;
+
     /**
-     * {@snippet :
- * int (*symlink)(char*,char*);
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*mknod)(const char *, mode_t, dev_t)
      * }
      */
-    public interface symlink {
-
-        int apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1);
-        static MemorySegment allocate(symlink fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$14.const$1, fi, constants$9.const$5, scope);
-        }
-        static symlink ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1) -> {
-                try {
-                    return (int)constants$10.const$1.invokeExact(symbol, __x0, __x1);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
-        }
+    public static final long mknod$offset() {
+        return mknod$OFFSET;
     }
 
-    public static VarHandle symlink$VH() {
-        return constants$14.const$2;
-    }
     /**
      * Getter for field:
-     * {@snippet :
-     * int (*symlink)(char*,char*);
+     * {@snippet lang=c :
+     * int (*mknod)(const char *, mode_t, dev_t)
      * }
      */
-    public static MemorySegment symlink$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$14.const$2.get(seg);
+    public static MemorySegment mknod(MemorySegment struct) {
+        return struct.get(mknod$LAYOUT, mknod$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int (*symlink)(char*,char*);
+     * {@snippet lang=c :
+     * int (*mknod)(const char *, mode_t, dev_t)
      * }
      */
-    public static void symlink$set(MemorySegment seg, MemorySegment x) {
-        constants$14.const$2.set(seg, x);
-    }
-    public static MemorySegment symlink$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$14.const$2.get(seg.asSlice(index*sizeof()));
-    }
-    public static void symlink$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$14.const$2.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static symlink symlink(MemorySegment segment, Arena scope) {
-        return symlink.ofAddress(symlink$get(segment), scope);
+    public static void mknod(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(mknod$LAYOUT, mknod$OFFSET, fieldValue);
     }
+
     /**
-     * {@snippet :
- * int (*rename)(char*,char*);
+     * {@snippet lang=c :
+     * int (*mkdir)(const char *, mode_t)
      * }
      */
-    public interface rename {
+    public static class mkdir {
 
-        int apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1);
-        static MemorySegment allocate(rename fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$14.const$3, fi, constants$9.const$5, scope);
+        mkdir() {
+            // Should not be called directly
         }
-        static rename ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1) -> {
-                try {
-                    return (int)constants$10.const$1.invokeExact(symbol, __x0, __x1);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, short _x1);
         }
-    }
 
-    public static VarHandle rename$VH() {
-        return constants$14.const$4;
-    }
-    /**
-     * Getter for field:
-     * {@snippet :
-     * int (*rename)(char*,char*);
-     * }
-     */
-    public static MemorySegment rename$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$14.const$4.get(seg);
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_SHORT
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(mkdir.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(mkdir.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, short _x1) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
     }
+
+    private static final AddressLayout mkdir$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("mkdir"));
+
     /**
-     * Setter for field:
-     * {@snippet :
-     * int (*rename)(char*,char*);
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*mkdir)(const char *, mode_t)
      * }
      */
-    public static void rename$set(MemorySegment seg, MemorySegment x) {
-        constants$14.const$4.set(seg, x);
-    }
-    public static MemorySegment rename$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$14.const$4.get(seg.asSlice(index*sizeof()));
-    }
-    public static void rename$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$14.const$4.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static rename rename(MemorySegment segment, Arena scope) {
-        return rename.ofAddress(rename$get(segment), scope);
+    public static final AddressLayout mkdir$layout() {
+        return mkdir$LAYOUT;
     }
+
+    private static final long mkdir$OFFSET = 32;
+
     /**
-     * {@snippet :
- * int (*link)(char*,char*);
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*mkdir)(const char *, mode_t)
      * }
      */
-    public interface link {
-
-        int apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1);
-        static MemorySegment allocate(link fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$14.const$5, fi, constants$9.const$5, scope);
-        }
-        static link ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1) -> {
-                try {
-                    return (int)constants$10.const$1.invokeExact(symbol, __x0, __x1);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
-        }
+    public static final long mkdir$offset() {
+        return mkdir$OFFSET;
     }
 
-    public static VarHandle link$VH() {
-        return constants$15.const$0;
-    }
     /**
      * Getter for field:
-     * {@snippet :
-     * int (*link)(char*,char*);
+     * {@snippet lang=c :
+     * int (*mkdir)(const char *, mode_t)
      * }
      */
-    public static MemorySegment link$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$15.const$0.get(seg);
+    public static MemorySegment mkdir(MemorySegment struct) {
+        return struct.get(mkdir$LAYOUT, mkdir$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int (*link)(char*,char*);
+     * {@snippet lang=c :
+     * int (*mkdir)(const char *, mode_t)
      * }
      */
-    public static void link$set(MemorySegment seg, MemorySegment x) {
-        constants$15.const$0.set(seg, x);
-    }
-    public static MemorySegment link$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$15.const$0.get(seg.asSlice(index*sizeof()));
-    }
-    public static void link$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$15.const$0.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static link link(MemorySegment segment, Arena scope) {
-        return link.ofAddress(link$get(segment), scope);
+    public static void mkdir(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(mkdir$LAYOUT, mkdir$OFFSET, fieldValue);
     }
+
     /**
-     * {@snippet :
- * int (*chmod)(char*,mode_t);
+     * {@snippet lang=c :
+     * int (*unlink)(const char *)
      * }
      */
-    public interface chmod {
+    public static class unlink {
 
-        int apply(java.lang.foreign.MemorySegment _x0, short _x1);
-        static MemorySegment allocate(chmod fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$15.const$1, fi, constants$12.const$3, scope);
+        unlink() {
+            // Should not be called directly
         }
-        static chmod ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, short __x1) -> {
-                try {
-                    return (int)constants$12.const$5.invokeExact(symbol, __x0, __x1);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0);
         }
-    }
 
-    public static VarHandle chmod$VH() {
-        return constants$15.const$2;
-    }
-    /**
-     * Getter for field:
-     * {@snippet :
-     * int (*chmod)(char*,mode_t);
-     * }
-     */
-    public static MemorySegment chmod$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$15.const$2.get(seg);
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(unlink.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(unlink.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
     }
+
+    private static final AddressLayout unlink$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("unlink"));
+
     /**
-     * Setter for field:
-     * {@snippet :
-     * int (*chmod)(char*,mode_t);
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*unlink)(const char *)
      * }
      */
-    public static void chmod$set(MemorySegment seg, MemorySegment x) {
-        constants$15.const$2.set(seg, x);
-    }
-    public static MemorySegment chmod$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$15.const$2.get(seg.asSlice(index*sizeof()));
-    }
-    public static void chmod$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$15.const$2.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static chmod chmod(MemorySegment segment, Arena scope) {
-        return chmod.ofAddress(chmod$get(segment), scope);
+    public static final AddressLayout unlink$layout() {
+        return unlink$LAYOUT;
     }
+
+    private static final long unlink$OFFSET = 40;
+
     /**
-     * {@snippet :
- * int (*chown)(char*,uid_t,gid_t);
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*unlink)(const char *)
      * }
      */
-    public interface chown {
-
-        int apply(java.lang.foreign.MemorySegment _x0, int _x1, int _x2);
-        static MemorySegment allocate(chown fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$15.const$4, fi, constants$15.const$3, scope);
-        }
-        static chown ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, int __x1, int __x2) -> {
-                try {
-                    return (int)constants$15.const$5.invokeExact(symbol, __x0, __x1, __x2);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
-        }
+    public static final long unlink$offset() {
+        return unlink$OFFSET;
     }
 
-    public static VarHandle chown$VH() {
-        return constants$16.const$0;
-    }
     /**
      * Getter for field:
-     * {@snippet :
-     * int (*chown)(char*,uid_t,gid_t);
+     * {@snippet lang=c :
+     * int (*unlink)(const char *)
      * }
      */
-    public static MemorySegment chown$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$16.const$0.get(seg);
+    public static MemorySegment unlink(MemorySegment struct) {
+        return struct.get(unlink$LAYOUT, unlink$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int (*chown)(char*,uid_t,gid_t);
+     * {@snippet lang=c :
+     * int (*unlink)(const char *)
      * }
      */
-    public static void chown$set(MemorySegment seg, MemorySegment x) {
-        constants$16.const$0.set(seg, x);
-    }
-    public static MemorySegment chown$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$16.const$0.get(seg.asSlice(index*sizeof()));
-    }
-    public static void chown$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$16.const$0.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static chown chown(MemorySegment segment, Arena scope) {
-        return chown.ofAddress(chown$get(segment), scope);
+    public static void unlink(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(unlink$LAYOUT, unlink$OFFSET, fieldValue);
     }
+
     /**
-     * {@snippet :
- * int (*truncate)(char*,off_t);
+     * {@snippet lang=c :
+     * int (*rmdir)(const char *)
      * }
      */
-    public interface truncate {
+    public static class rmdir {
 
-        int apply(java.lang.foreign.MemorySegment _x0, long _x1);
-        static MemorySegment allocate(truncate fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$16.const$2, fi, constants$16.const$1, scope);
+        rmdir() {
+            // Should not be called directly
         }
-        static truncate ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, long __x1) -> {
-                try {
-                    return (int)constants$16.const$3.invokeExact(symbol, __x0, __x1);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0);
         }
-    }
 
-    public static VarHandle truncate$VH() {
-        return constants$16.const$4;
-    }
-    /**
-     * Getter for field:
-     * {@snippet :
-     * int (*truncate)(char*,off_t);
-     * }
-     */
-    public static MemorySegment truncate$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$16.const$4.get(seg);
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(rmdir.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(rmdir.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
     }
+
+    private static final AddressLayout rmdir$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("rmdir"));
+
     /**
-     * Setter for field:
-     * {@snippet :
-     * int (*truncate)(char*,off_t);
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*rmdir)(const char *)
      * }
      */
-    public static void truncate$set(MemorySegment seg, MemorySegment x) {
-        constants$16.const$4.set(seg, x);
-    }
-    public static MemorySegment truncate$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$16.const$4.get(seg.asSlice(index*sizeof()));
-    }
-    public static void truncate$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$16.const$4.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static truncate truncate(MemorySegment segment, Arena scope) {
-        return truncate.ofAddress(truncate$get(segment), scope);
+    public static final AddressLayout rmdir$layout() {
+        return rmdir$LAYOUT;
     }
+
+    private static final long rmdir$OFFSET = 48;
+
     /**
-     * {@snippet :
- * int (*utime)(char*,struct utimbuf*);
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*rmdir)(const char *)
      * }
      */
-    public interface utime {
-
-        int apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1);
-        static MemorySegment allocate(utime fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$16.const$5, fi, constants$9.const$5, scope);
-        }
-        static utime ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1) -> {
-                try {
-                    return (int)constants$10.const$1.invokeExact(symbol, __x0, __x1);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
-        }
+    public static final long rmdir$offset() {
+        return rmdir$OFFSET;
     }
 
-    public static VarHandle utime$VH() {
-        return constants$17.const$0;
-    }
     /**
      * Getter for field:
-     * {@snippet :
-     * int (*utime)(char*,struct utimbuf*);
+     * {@snippet lang=c :
+     * int (*rmdir)(const char *)
      * }
      */
-    public static MemorySegment utime$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$17.const$0.get(seg);
+    public static MemorySegment rmdir(MemorySegment struct) {
+        return struct.get(rmdir$LAYOUT, rmdir$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int (*utime)(char*,struct utimbuf*);
+     * {@snippet lang=c :
+     * int (*rmdir)(const char *)
      * }
      */
-    public static void utime$set(MemorySegment seg, MemorySegment x) {
-        constants$17.const$0.set(seg, x);
-    }
-    public static MemorySegment utime$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$17.const$0.get(seg.asSlice(index*sizeof()));
-    }
-    public static void utime$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$17.const$0.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static utime utime(MemorySegment segment, Arena scope) {
-        return utime.ofAddress(utime$get(segment), scope);
+    public static void rmdir(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(rmdir$LAYOUT, rmdir$OFFSET, fieldValue);
     }
+
     /**
-     * {@snippet :
- * int (*open)(char*,struct fuse_file_info*);
+     * {@snippet lang=c :
+     * int (*symlink)(const char *, const char *)
      * }
      */
-    public interface open {
+    public static class symlink {
+
+        symlink() {
+            // Should not be called directly
+        }
 
-        int apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1);
-        static MemorySegment allocate(open fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$17.const$1, fi, constants$9.const$5, scope);
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, MemorySegment _x1);
         }
-        static open ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1) -> {
-                try {
-                    return (int)constants$10.const$1.invokeExact(symbol, __x0, __x1);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
         }
-    }
 
-    public static VarHandle open$VH() {
-        return constants$17.const$2;
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(symlink.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(symlink.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
     }
+
+    private static final AddressLayout symlink$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("symlink"));
+
     /**
-     * Getter for field:
-     * {@snippet :
-     * int (*open)(char*,struct fuse_file_info*);
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*symlink)(const char *, const char *)
      * }
      */
-    public static MemorySegment open$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$17.const$2.get(seg);
+    public static final AddressLayout symlink$layout() {
+        return symlink$LAYOUT;
     }
+
+    private static final long symlink$OFFSET = 56;
+
     /**
-     * Setter for field:
-     * {@snippet :
-     * int (*open)(char*,struct fuse_file_info*);
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*symlink)(const char *, const char *)
      * }
      */
-    public static void open$set(MemorySegment seg, MemorySegment x) {
-        constants$17.const$2.set(seg, x);
-    }
-    public static MemorySegment open$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$17.const$2.get(seg.asSlice(index*sizeof()));
-    }
-    public static void open$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$17.const$2.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static open open(MemorySegment segment, Arena scope) {
-        return open.ofAddress(open$get(segment), scope);
+    public static final long symlink$offset() {
+        return symlink$OFFSET;
     }
+
     /**
-     * {@snippet :
- * int (*read)(char*,char*,size_t,off_t,struct fuse_file_info*);
+     * Getter for field:
+     * {@snippet lang=c :
+     * int (*symlink)(const char *, const char *)
      * }
      */
-    public interface read {
-
-        int apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1, long _x2, long _x3, java.lang.foreign.MemorySegment _x4);
-        static MemorySegment allocate(read fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$17.const$4, fi, constants$17.const$3, scope);
-        }
-        static read ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1, long __x2, long __x3, java.lang.foreign.MemorySegment __x4) -> {
-                try {
-                    return (int)constants$17.const$5.invokeExact(symbol, __x0, __x1, __x2, __x3, __x4);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
-        }
+    public static MemorySegment symlink(MemorySegment struct) {
+        return struct.get(symlink$LAYOUT, symlink$OFFSET);
     }
 
-    public static VarHandle read$VH() {
-        return constants$18.const$0;
-    }
-    /**
-     * Getter for field:
-     * {@snippet :
-     * int (*read)(char*,char*,size_t,off_t,struct fuse_file_info*);
-     * }
-     */
-    public static MemorySegment read$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$18.const$0.get(seg);
-    }
     /**
      * Setter for field:
-     * {@snippet :
-     * int (*read)(char*,char*,size_t,off_t,struct fuse_file_info*);
+     * {@snippet lang=c :
+     * int (*symlink)(const char *, const char *)
      * }
      */
-    public static void read$set(MemorySegment seg, MemorySegment x) {
-        constants$18.const$0.set(seg, x);
-    }
-    public static MemorySegment read$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$18.const$0.get(seg.asSlice(index*sizeof()));
-    }
-    public static void read$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$18.const$0.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static read read(MemorySegment segment, Arena scope) {
-        return read.ofAddress(read$get(segment), scope);
+    public static void symlink(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(symlink$LAYOUT, symlink$OFFSET, fieldValue);
     }
+
     /**
-     * {@snippet :
- * int (*write)(char*,char*,size_t,off_t,struct fuse_file_info*);
+     * {@snippet lang=c :
+     * int (*rename)(const char *, const char *)
      * }
      */
-    public interface write {
+    public static class rename {
 
-        int apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1, long _x2, long _x3, java.lang.foreign.MemorySegment _x4);
-        static MemorySegment allocate(write fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$18.const$1, fi, constants$17.const$3, scope);
+        rename() {
+            // Should not be called directly
         }
-        static write ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1, long __x2, long __x3, java.lang.foreign.MemorySegment __x4) -> {
-                try {
-                    return (int)constants$17.const$5.invokeExact(symbol, __x0, __x1, __x2, __x3, __x4);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, MemorySegment _x1);
         }
-    }
 
-    public static VarHandle write$VH() {
-        return constants$18.const$2;
-    }
-    /**
-     * Getter for field:
-     * {@snippet :
-     * int (*write)(char*,char*,size_t,off_t,struct fuse_file_info*);
-     * }
-     */
-    public static MemorySegment write$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$18.const$2.get(seg);
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(rename.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(rename.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
     }
+
+    private static final AddressLayout rename$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("rename"));
+
     /**
-     * Setter for field:
-     * {@snippet :
-     * int (*write)(char*,char*,size_t,off_t,struct fuse_file_info*);
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*rename)(const char *, const char *)
      * }
      */
-    public static void write$set(MemorySegment seg, MemorySegment x) {
-        constants$18.const$2.set(seg, x);
-    }
-    public static MemorySegment write$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$18.const$2.get(seg.asSlice(index*sizeof()));
-    }
-    public static void write$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$18.const$2.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static write write(MemorySegment segment, Arena scope) {
-        return write.ofAddress(write$get(segment), scope);
+    public static final AddressLayout rename$layout() {
+        return rename$LAYOUT;
     }
+
+    private static final long rename$OFFSET = 64;
+
     /**
-     * {@snippet :
- * int (*statfs)(char*,struct statvfs*);
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*rename)(const char *, const char *)
      * }
      */
-    public interface statfs {
-
-        int apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1);
-        static MemorySegment allocate(statfs fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$18.const$3, fi, constants$9.const$5, scope);
-        }
-        static statfs ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1) -> {
-                try {
-                    return (int)constants$10.const$1.invokeExact(symbol, __x0, __x1);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
-        }
+    public static final long rename$offset() {
+        return rename$OFFSET;
     }
 
-    public static VarHandle statfs$VH() {
-        return constants$18.const$4;
-    }
     /**
      * Getter for field:
-     * {@snippet :
-     * int (*statfs)(char*,struct statvfs*);
+     * {@snippet lang=c :
+     * int (*rename)(const char *, const char *)
      * }
      */
-    public static MemorySegment statfs$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$18.const$4.get(seg);
+    public static MemorySegment rename(MemorySegment struct) {
+        return struct.get(rename$LAYOUT, rename$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int (*statfs)(char*,struct statvfs*);
+     * {@snippet lang=c :
+     * int (*rename)(const char *, const char *)
      * }
      */
-    public static void statfs$set(MemorySegment seg, MemorySegment x) {
-        constants$18.const$4.set(seg, x);
-    }
-    public static MemorySegment statfs$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$18.const$4.get(seg.asSlice(index*sizeof()));
-    }
-    public static void statfs$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$18.const$4.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static statfs statfs(MemorySegment segment, Arena scope) {
-        return statfs.ofAddress(statfs$get(segment), scope);
+    public static void rename(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(rename$LAYOUT, rename$OFFSET, fieldValue);
     }
+
     /**
-     * {@snippet :
- * int (*flush)(char*,struct fuse_file_info*);
+     * {@snippet lang=c :
+     * int (*link)(const char *, const char *)
      * }
      */
-    public interface flush {
+    public static class link {
 
-        int apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1);
-        static MemorySegment allocate(flush fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$18.const$5, fi, constants$9.const$5, scope);
+        link() {
+            // Should not be called directly
         }
-        static flush ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1) -> {
-                try {
-                    return (int)constants$10.const$1.invokeExact(symbol, __x0, __x1);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, MemorySegment _x1);
         }
-    }
 
-    public static VarHandle flush$VH() {
-        return constants$19.const$0;
-    }
-    /**
-     * Getter for field:
-     * {@snippet :
-     * int (*flush)(char*,struct fuse_file_info*);
-     * }
-     */
-    public static MemorySegment flush$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$19.const$0.get(seg);
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(link.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(link.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
     }
+
+    private static final AddressLayout link$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("link"));
+
     /**
-     * Setter for field:
-     * {@snippet :
-     * int (*flush)(char*,struct fuse_file_info*);
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*link)(const char *, const char *)
      * }
      */
-    public static void flush$set(MemorySegment seg, MemorySegment x) {
-        constants$19.const$0.set(seg, x);
-    }
-    public static MemorySegment flush$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$19.const$0.get(seg.asSlice(index*sizeof()));
-    }
-    public static void flush$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$19.const$0.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static flush flush(MemorySegment segment, Arena scope) {
-        return flush.ofAddress(flush$get(segment), scope);
+    public static final AddressLayout link$layout() {
+        return link$LAYOUT;
     }
+
+    private static final long link$OFFSET = 72;
+
     /**
-     * {@snippet :
- * int (*release)(char*,struct fuse_file_info*);
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*link)(const char *, const char *)
      * }
      */
-    public interface release {
-
-        int apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1);
-        static MemorySegment allocate(release fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$19.const$1, fi, constants$9.const$5, scope);
-        }
-        static release ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1) -> {
-                try {
-                    return (int)constants$10.const$1.invokeExact(symbol, __x0, __x1);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
-        }
+    public static final long link$offset() {
+        return link$OFFSET;
     }
 
-    public static VarHandle release$VH() {
-        return constants$19.const$2;
-    }
     /**
      * Getter for field:
-     * {@snippet :
-     * int (*release)(char*,struct fuse_file_info*);
+     * {@snippet lang=c :
+     * int (*link)(const char *, const char *)
      * }
      */
-    public static MemorySegment release$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$19.const$2.get(seg);
+    public static MemorySegment link(MemorySegment struct) {
+        return struct.get(link$LAYOUT, link$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int (*release)(char*,struct fuse_file_info*);
+     * {@snippet lang=c :
+     * int (*link)(const char *, const char *)
      * }
      */
-    public static void release$set(MemorySegment seg, MemorySegment x) {
-        constants$19.const$2.set(seg, x);
-    }
-    public static MemorySegment release$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$19.const$2.get(seg.asSlice(index*sizeof()));
-    }
-    public static void release$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$19.const$2.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static release release(MemorySegment segment, Arena scope) {
-        return release.ofAddress(release$get(segment), scope);
+    public static void link(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(link$LAYOUT, link$OFFSET, fieldValue);
     }
+
     /**
-     * {@snippet :
- * int (*fsync)(char*,int,struct fuse_file_info*);
+     * {@snippet lang=c :
+     * int (*chmod)(const char *, mode_t)
      * }
      */
-    public interface fsync {
+    public static class chmod {
 
-        int apply(java.lang.foreign.MemorySegment _x0, int _x1, java.lang.foreign.MemorySegment _x2);
-        static MemorySegment allocate(fsync fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$19.const$4, fi, constants$19.const$3, scope);
+        chmod() {
+            // Should not be called directly
         }
-        static fsync ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, int __x1, java.lang.foreign.MemorySegment __x2) -> {
-                try {
-                    return (int)constants$19.const$5.invokeExact(symbol, __x0, __x1, __x2);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, short _x1);
         }
-    }
 
-    public static VarHandle fsync$VH() {
-        return constants$20.const$0;
-    }
-    /**
-     * Getter for field:
-     * {@snippet :
-     * int (*fsync)(char*,int,struct fuse_file_info*);
-     * }
-     */
-    public static MemorySegment fsync$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$20.const$0.get(seg);
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_SHORT
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(chmod.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(chmod.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, short _x1) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
     }
+
+    private static final AddressLayout chmod$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("chmod"));
+
     /**
-     * Setter for field:
-     * {@snippet :
-     * int (*fsync)(char*,int,struct fuse_file_info*);
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*chmod)(const char *, mode_t)
      * }
      */
-    public static void fsync$set(MemorySegment seg, MemorySegment x) {
-        constants$20.const$0.set(seg, x);
-    }
-    public static MemorySegment fsync$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$20.const$0.get(seg.asSlice(index*sizeof()));
-    }
-    public static void fsync$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$20.const$0.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static fsync fsync(MemorySegment segment, Arena scope) {
-        return fsync.ofAddress(fsync$get(segment), scope);
+    public static final AddressLayout chmod$layout() {
+        return chmod$LAYOUT;
     }
+
+    private static final long chmod$OFFSET = 80;
+
     /**
-     * {@snippet :
- * int (*setxattr)(char*,char*,char*,size_t,int);
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*chmod)(const char *, mode_t)
      * }
      */
-    public interface setxattr {
-
-        int apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1, java.lang.foreign.MemorySegment _x2, long _x3, int _x4);
-        static MemorySegment allocate(setxattr fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$20.const$2, fi, constants$20.const$1, scope);
-        }
-        static setxattr ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1, java.lang.foreign.MemorySegment __x2, long __x3, int __x4) -> {
-                try {
-                    return (int)constants$20.const$3.invokeExact(symbol, __x0, __x1, __x2, __x3, __x4);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
-        }
+    public static final long chmod$offset() {
+        return chmod$OFFSET;
     }
 
-    public static VarHandle setxattr$VH() {
-        return constants$20.const$4;
-    }
     /**
      * Getter for field:
-     * {@snippet :
-     * int (*setxattr)(char*,char*,char*,size_t,int);
+     * {@snippet lang=c :
+     * int (*chmod)(const char *, mode_t)
      * }
      */
-    public static MemorySegment setxattr$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$20.const$4.get(seg);
+    public static MemorySegment chmod(MemorySegment struct) {
+        return struct.get(chmod$LAYOUT, chmod$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int (*setxattr)(char*,char*,char*,size_t,int);
+     * {@snippet lang=c :
+     * int (*chmod)(const char *, mode_t)
      * }
      */
-    public static void setxattr$set(MemorySegment seg, MemorySegment x) {
-        constants$20.const$4.set(seg, x);
-    }
-    public static MemorySegment setxattr$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$20.const$4.get(seg.asSlice(index*sizeof()));
-    }
-    public static void setxattr$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$20.const$4.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static setxattr setxattr(MemorySegment segment, Arena scope) {
-        return setxattr.ofAddress(setxattr$get(segment), scope);
+    public static void chmod(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(chmod$LAYOUT, chmod$OFFSET, fieldValue);
     }
+
     /**
-     * {@snippet :
- * int (*getxattr)(char*,char*,char*,size_t);
+     * {@snippet lang=c :
+     * int (*chown)(const char *, uid_t, gid_t)
      * }
      */
-    public interface getxattr {
+    public static class chown {
+
+        chown() {
+            // Should not be called directly
+        }
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, int _x1, int _x2);
+        }
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_INT,
+            fuse_h.C_INT
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
 
-        int apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1, java.lang.foreign.MemorySegment _x2, long _x3);
-        static MemorySegment allocate(getxattr fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$20.const$5, fi, constants$9.const$1, scope);
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(chown.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(chown.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
         }
-        static getxattr ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1, java.lang.foreign.MemorySegment __x2, long __x3) -> {
-                try {
-                    return (int)constants$9.const$3.invokeExact(symbol, __x0, __x1, __x2, __x3);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, int _x1, int _x2) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
         }
     }
 
-    public static VarHandle getxattr$VH() {
-        return constants$21.const$0;
+    private static final AddressLayout chown$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("chown"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*chown)(const char *, uid_t, gid_t)
+     * }
+     */
+    public static final AddressLayout chown$layout() {
+        return chown$LAYOUT;
+    }
+
+    private static final long chown$OFFSET = 88;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*chown)(const char *, uid_t, gid_t)
+     * }
+     */
+    public static final long chown$offset() {
+        return chown$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int (*getxattr)(char*,char*,char*,size_t);
+     * {@snippet lang=c :
+     * int (*chown)(const char *, uid_t, gid_t)
      * }
      */
-    public static MemorySegment getxattr$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$21.const$0.get(seg);
+    public static MemorySegment chown(MemorySegment struct) {
+        return struct.get(chown$LAYOUT, chown$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int (*getxattr)(char*,char*,char*,size_t);
+     * {@snippet lang=c :
+     * int (*chown)(const char *, uid_t, gid_t)
      * }
      */
-    public static void getxattr$set(MemorySegment seg, MemorySegment x) {
-        constants$21.const$0.set(seg, x);
-    }
-    public static MemorySegment getxattr$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$21.const$0.get(seg.asSlice(index*sizeof()));
-    }
-    public static void getxattr$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$21.const$0.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static getxattr getxattr(MemorySegment segment, Arena scope) {
-        return getxattr.ofAddress(getxattr$get(segment), scope);
+    public static void chown(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(chown$LAYOUT, chown$OFFSET, fieldValue);
     }
+
     /**
-     * {@snippet :
- * int (*listxattr)(char*,char*,size_t);
+     * {@snippet lang=c :
+     * int (*truncate)(const char *, off_t)
      * }
      */
-    public interface listxattr {
+    public static class truncate {
+
+        truncate() {
+            // Should not be called directly
+        }
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, long _x1);
+        }
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_LONG_LONG
+        );
 
-        int apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1, long _x2);
-        static MemorySegment allocate(listxattr fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$21.const$1, fi, constants$10.const$3, scope);
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
         }
-        static listxattr ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1, long __x2) -> {
-                try {
-                    return (int)constants$10.const$5.invokeExact(symbol, __x0, __x1, __x2);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(truncate.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(truncate.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, long _x1) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
         }
     }
 
-    public static VarHandle listxattr$VH() {
-        return constants$21.const$2;
+    private static final AddressLayout truncate$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("truncate"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*truncate)(const char *, off_t)
+     * }
+     */
+    public static final AddressLayout truncate$layout() {
+        return truncate$LAYOUT;
+    }
+
+    private static final long truncate$OFFSET = 96;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*truncate)(const char *, off_t)
+     * }
+     */
+    public static final long truncate$offset() {
+        return truncate$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int (*listxattr)(char*,char*,size_t);
+     * {@snippet lang=c :
+     * int (*truncate)(const char *, off_t)
      * }
      */
-    public static MemorySegment listxattr$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$21.const$2.get(seg);
+    public static MemorySegment truncate(MemorySegment struct) {
+        return struct.get(truncate$LAYOUT, truncate$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int (*listxattr)(char*,char*,size_t);
+     * {@snippet lang=c :
+     * int (*truncate)(const char *, off_t)
      * }
      */
-    public static void listxattr$set(MemorySegment seg, MemorySegment x) {
-        constants$21.const$2.set(seg, x);
-    }
-    public static MemorySegment listxattr$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$21.const$2.get(seg.asSlice(index*sizeof()));
-    }
-    public static void listxattr$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$21.const$2.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static listxattr listxattr(MemorySegment segment, Arena scope) {
-        return listxattr.ofAddress(listxattr$get(segment), scope);
+    public static void truncate(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(truncate$LAYOUT, truncate$OFFSET, fieldValue);
     }
+
     /**
-     * {@snippet :
- * int (*removexattr)(char*,char*);
+     * {@snippet lang=c :
+     * int (*utime)(const char *, struct utimbuf *)
      * }
      */
-    public interface removexattr {
+    public static class utime {
+
+        utime() {
+            // Should not be called directly
+        }
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, MemorySegment _x1);
+        }
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
 
-        int apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1);
-        static MemorySegment allocate(removexattr fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$21.const$3, fi, constants$9.const$5, scope);
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(utime.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(utime.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
         }
-        static removexattr ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1) -> {
-                try {
-                    return (int)constants$10.const$1.invokeExact(symbol, __x0, __x1);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
         }
     }
 
-    public static VarHandle removexattr$VH() {
-        return constants$21.const$4;
+    private static final AddressLayout utime$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("utime"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*utime)(const char *, struct utimbuf *)
+     * }
+     */
+    public static final AddressLayout utime$layout() {
+        return utime$LAYOUT;
+    }
+
+    private static final long utime$OFFSET = 104;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*utime)(const char *, struct utimbuf *)
+     * }
+     */
+    public static final long utime$offset() {
+        return utime$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int (*removexattr)(char*,char*);
+     * {@snippet lang=c :
+     * int (*utime)(const char *, struct utimbuf *)
      * }
      */
-    public static MemorySegment removexattr$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$21.const$4.get(seg);
+    public static MemorySegment utime(MemorySegment struct) {
+        return struct.get(utime$LAYOUT, utime$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int (*removexattr)(char*,char*);
+     * {@snippet lang=c :
+     * int (*utime)(const char *, struct utimbuf *)
      * }
      */
-    public static void removexattr$set(MemorySegment seg, MemorySegment x) {
-        constants$21.const$4.set(seg, x);
-    }
-    public static MemorySegment removexattr$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$21.const$4.get(seg.asSlice(index*sizeof()));
-    }
-    public static void removexattr$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$21.const$4.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static removexattr removexattr(MemorySegment segment, Arena scope) {
-        return removexattr.ofAddress(removexattr$get(segment), scope);
+    public static void utime(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(utime$LAYOUT, utime$OFFSET, fieldValue);
     }
+
     /**
-     * {@snippet :
- * int (*opendir)(char*,struct fuse_file_info*);
+     * {@snippet lang=c :
+     * int (*open)(const char *, struct fuse_file_info *)
      * }
      */
-    public interface opendir {
+    public static class open {
+
+        open() {
+            // Should not be called directly
+        }
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, MemorySegment _x1);
+        }
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER
+        );
 
-        int apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1);
-        static MemorySegment allocate(opendir fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$21.const$5, fi, constants$9.const$5, scope);
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
         }
-        static opendir ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1) -> {
-                try {
-                    return (int)constants$10.const$1.invokeExact(symbol, __x0, __x1);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(open.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(open.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
         }
     }
 
-    public static VarHandle opendir$VH() {
-        return constants$22.const$0;
+    private static final AddressLayout open$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("open"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*open)(const char *, struct fuse_file_info *)
+     * }
+     */
+    public static final AddressLayout open$layout() {
+        return open$LAYOUT;
+    }
+
+    private static final long open$OFFSET = 112;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*open)(const char *, struct fuse_file_info *)
+     * }
+     */
+    public static final long open$offset() {
+        return open$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int (*opendir)(char*,struct fuse_file_info*);
+     * {@snippet lang=c :
+     * int (*open)(const char *, struct fuse_file_info *)
      * }
      */
-    public static MemorySegment opendir$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$22.const$0.get(seg);
+    public static MemorySegment open(MemorySegment struct) {
+        return struct.get(open$LAYOUT, open$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int (*opendir)(char*,struct fuse_file_info*);
+     * {@snippet lang=c :
+     * int (*open)(const char *, struct fuse_file_info *)
      * }
      */
-    public static void opendir$set(MemorySegment seg, MemorySegment x) {
-        constants$22.const$0.set(seg, x);
-    }
-    public static MemorySegment opendir$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$22.const$0.get(seg.asSlice(index*sizeof()));
-    }
-    public static void opendir$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$22.const$0.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static opendir opendir(MemorySegment segment, Arena scope) {
-        return opendir.ofAddress(opendir$get(segment), scope);
+    public static void open(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(open$LAYOUT, open$OFFSET, fieldValue);
     }
+
     /**
-     * {@snippet :
- * int (*readdir)(char*,void*,fuse_fill_dir_t,off_t,struct fuse_file_info*);
+     * {@snippet lang=c :
+     * int (*read)(const char *, char *, size_t, off_t, struct fuse_file_info *)
      * }
      */
-    public interface readdir {
+    public static class read {
+
+        read() {
+            // Should not be called directly
+        }
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, MemorySegment _x1, long _x2, long _x3, MemorySegment _x4);
+        }
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER,
+            fuse_h.C_LONG,
+            fuse_h.C_LONG_LONG,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
 
-        int apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1, java.lang.foreign.MemorySegment _x2, long _x3, java.lang.foreign.MemorySegment _x4);
-        static MemorySegment allocate(readdir fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$22.const$2, fi, constants$22.const$1, scope);
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(read.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(read.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
         }
-        static readdir ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1, java.lang.foreign.MemorySegment __x2, long __x3, java.lang.foreign.MemorySegment __x4) -> {
-                try {
-                    return (int)constants$22.const$3.invokeExact(symbol, __x0, __x1, __x2, __x3, __x4);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1, long _x2, long _x3, MemorySegment _x4) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2, _x3, _x4);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
         }
     }
 
-    public static VarHandle readdir$VH() {
-        return constants$22.const$4;
+    private static final AddressLayout read$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("read"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*read)(const char *, char *, size_t, off_t, struct fuse_file_info *)
+     * }
+     */
+    public static final AddressLayout read$layout() {
+        return read$LAYOUT;
+    }
+
+    private static final long read$OFFSET = 120;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*read)(const char *, char *, size_t, off_t, struct fuse_file_info *)
+     * }
+     */
+    public static final long read$offset() {
+        return read$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int (*readdir)(char*,void*,fuse_fill_dir_t,off_t,struct fuse_file_info*);
+     * {@snippet lang=c :
+     * int (*read)(const char *, char *, size_t, off_t, struct fuse_file_info *)
      * }
      */
-    public static MemorySegment readdir$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$22.const$4.get(seg);
+    public static MemorySegment read(MemorySegment struct) {
+        return struct.get(read$LAYOUT, read$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int (*readdir)(char*,void*,fuse_fill_dir_t,off_t,struct fuse_file_info*);
+     * {@snippet lang=c :
+     * int (*read)(const char *, char *, size_t, off_t, struct fuse_file_info *)
      * }
      */
-    public static void readdir$set(MemorySegment seg, MemorySegment x) {
-        constants$22.const$4.set(seg, x);
-    }
-    public static MemorySegment readdir$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$22.const$4.get(seg.asSlice(index*sizeof()));
-    }
-    public static void readdir$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$22.const$4.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static readdir readdir(MemorySegment segment, Arena scope) {
-        return readdir.ofAddress(readdir$get(segment), scope);
+    public static void read(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(read$LAYOUT, read$OFFSET, fieldValue);
     }
+
     /**
-     * {@snippet :
- * int (*releasedir)(char*,struct fuse_file_info*);
+     * {@snippet lang=c :
+     * int (*write)(const char *, const char *, size_t, off_t, struct fuse_file_info *)
      * }
      */
-    public interface releasedir {
+    public static class write {
+
+        write() {
+            // Should not be called directly
+        }
 
-        int apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1);
-        static MemorySegment allocate(releasedir fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$22.const$5, fi, constants$9.const$5, scope);
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, MemorySegment _x1, long _x2, long _x3, MemorySegment _x4);
         }
-        static releasedir ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1) -> {
-                try {
-                    return (int)constants$10.const$1.invokeExact(symbol, __x0, __x1);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER,
+            fuse_h.C_LONG,
+            fuse_h.C_LONG_LONG,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
         }
-    }
 
-    public static VarHandle releasedir$VH() {
-        return constants$23.const$0;
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(write.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(write.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1, long _x2, long _x3, MemorySegment _x4) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2, _x3, _x4);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
     }
+
+    private static final AddressLayout write$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("write"));
+
     /**
-     * Getter for field:
-     * {@snippet :
-     * int (*releasedir)(char*,struct fuse_file_info*);
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*write)(const char *, const char *, size_t, off_t, struct fuse_file_info *)
      * }
      */
-    public static MemorySegment releasedir$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$23.const$0.get(seg);
+    public static final AddressLayout write$layout() {
+        return write$LAYOUT;
     }
+
+    private static final long write$OFFSET = 128;
+
     /**
-     * Setter for field:
-     * {@snippet :
-     * int (*releasedir)(char*,struct fuse_file_info*);
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*write)(const char *, const char *, size_t, off_t, struct fuse_file_info *)
      * }
      */
-    public static void releasedir$set(MemorySegment seg, MemorySegment x) {
-        constants$23.const$0.set(seg, x);
-    }
-    public static MemorySegment releasedir$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$23.const$0.get(seg.asSlice(index*sizeof()));
+    public static final long write$offset() {
+        return write$OFFSET;
     }
-    public static void releasedir$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$23.const$0.set(seg.asSlice(index*sizeof()), x);
+
+    /**
+     * Getter for field:
+     * {@snippet lang=c :
+     * int (*write)(const char *, const char *, size_t, off_t, struct fuse_file_info *)
+     * }
+     */
+    public static MemorySegment write(MemorySegment struct) {
+        return struct.get(write$LAYOUT, write$OFFSET);
+    }
+
+    /**
+     * Setter for field:
+     * {@snippet lang=c :
+     * int (*write)(const char *, const char *, size_t, off_t, struct fuse_file_info *)
+     * }
+     */
+    public static void write(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(write$LAYOUT, write$OFFSET, fieldValue);
+    }
+
+    /**
+     * {@snippet lang=c :
+     * int (*statfs)(const char *, struct statvfs *)
+     * }
+     */
+    public static class statfs {
+
+        statfs() {
+            // Should not be called directly
+        }
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, MemorySegment _x1);
+        }
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(statfs.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(statfs.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
+    }
+
+    private static final AddressLayout statfs$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("statfs"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*statfs)(const char *, struct statvfs *)
+     * }
+     */
+    public static final AddressLayout statfs$layout() {
+        return statfs$LAYOUT;
+    }
+
+    private static final long statfs$OFFSET = 136;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*statfs)(const char *, struct statvfs *)
+     * }
+     */
+    public static final long statfs$offset() {
+        return statfs$OFFSET;
+    }
+
+    /**
+     * Getter for field:
+     * {@snippet lang=c :
+     * int (*statfs)(const char *, struct statvfs *)
+     * }
+     */
+    public static MemorySegment statfs(MemorySegment struct) {
+        return struct.get(statfs$LAYOUT, statfs$OFFSET);
+    }
+
+    /**
+     * Setter for field:
+     * {@snippet lang=c :
+     * int (*statfs)(const char *, struct statvfs *)
+     * }
+     */
+    public static void statfs(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(statfs$LAYOUT, statfs$OFFSET, fieldValue);
+    }
+
+    /**
+     * {@snippet lang=c :
+     * int (*flush)(const char *, struct fuse_file_info *)
+     * }
+     */
+    public static class flush {
+
+        flush() {
+            // Should not be called directly
+        }
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, MemorySegment _x1);
+        }
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(flush.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(flush.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
+    }
+
+    private static final AddressLayout flush$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("flush"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*flush)(const char *, struct fuse_file_info *)
+     * }
+     */
+    public static final AddressLayout flush$layout() {
+        return flush$LAYOUT;
+    }
+
+    private static final long flush$OFFSET = 144;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*flush)(const char *, struct fuse_file_info *)
+     * }
+     */
+    public static final long flush$offset() {
+        return flush$OFFSET;
+    }
+
+    /**
+     * Getter for field:
+     * {@snippet lang=c :
+     * int (*flush)(const char *, struct fuse_file_info *)
+     * }
+     */
+    public static MemorySegment flush(MemorySegment struct) {
+        return struct.get(flush$LAYOUT, flush$OFFSET);
+    }
+
+    /**
+     * Setter for field:
+     * {@snippet lang=c :
+     * int (*flush)(const char *, struct fuse_file_info *)
+     * }
+     */
+    public static void flush(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(flush$LAYOUT, flush$OFFSET, fieldValue);
+    }
+
+    /**
+     * {@snippet lang=c :
+     * int (*release)(const char *, struct fuse_file_info *)
+     * }
+     */
+    public static class release {
+
+        release() {
+            // Should not be called directly
+        }
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, MemorySegment _x1);
+        }
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(release.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(release.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
+    }
+
+    private static final AddressLayout release$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("release"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*release)(const char *, struct fuse_file_info *)
+     * }
+     */
+    public static final AddressLayout release$layout() {
+        return release$LAYOUT;
+    }
+
+    private static final long release$OFFSET = 152;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*release)(const char *, struct fuse_file_info *)
+     * }
+     */
+    public static final long release$offset() {
+        return release$OFFSET;
+    }
+
+    /**
+     * Getter for field:
+     * {@snippet lang=c :
+     * int (*release)(const char *, struct fuse_file_info *)
+     * }
+     */
+    public static MemorySegment release(MemorySegment struct) {
+        return struct.get(release$LAYOUT, release$OFFSET);
+    }
+
+    /**
+     * Setter for field:
+     * {@snippet lang=c :
+     * int (*release)(const char *, struct fuse_file_info *)
+     * }
+     */
+    public static void release(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(release$LAYOUT, release$OFFSET, fieldValue);
+    }
+
+    /**
+     * {@snippet lang=c :
+     * int (*fsync)(const char *, int, struct fuse_file_info *)
+     * }
+     */
+    public static class fsync {
+
+        fsync() {
+            // Should not be called directly
+        }
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, int _x1, MemorySegment _x2);
+        }
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_INT,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(fsync.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(fsync.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, int _x1, MemorySegment _x2) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
+    }
+
+    private static final AddressLayout fsync$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("fsync"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*fsync)(const char *, int, struct fuse_file_info *)
+     * }
+     */
+    public static final AddressLayout fsync$layout() {
+        return fsync$LAYOUT;
+    }
+
+    private static final long fsync$OFFSET = 160;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*fsync)(const char *, int, struct fuse_file_info *)
+     * }
+     */
+    public static final long fsync$offset() {
+        return fsync$OFFSET;
+    }
+
+    /**
+     * Getter for field:
+     * {@snippet lang=c :
+     * int (*fsync)(const char *, int, struct fuse_file_info *)
+     * }
+     */
+    public static MemorySegment fsync(MemorySegment struct) {
+        return struct.get(fsync$LAYOUT, fsync$OFFSET);
+    }
+
+    /**
+     * Setter for field:
+     * {@snippet lang=c :
+     * int (*fsync)(const char *, int, struct fuse_file_info *)
+     * }
+     */
+    public static void fsync(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(fsync$LAYOUT, fsync$OFFSET, fieldValue);
+    }
+
+    /**
+     * {@snippet lang=c :
+     * int (*setxattr)(const char *, const char *, const char *, size_t, int)
+     * }
+     */
+    public static class setxattr {
+
+        setxattr() {
+            // Should not be called directly
+        }
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, MemorySegment _x1, MemorySegment _x2, long _x3, int _x4);
+        }
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER,
+            fuse_h.C_LONG,
+            fuse_h.C_INT
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(setxattr.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(setxattr.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1, MemorySegment _x2, long _x3, int _x4) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2, _x3, _x4);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
+    }
+
+    private static final AddressLayout setxattr$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("setxattr"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*setxattr)(const char *, const char *, const char *, size_t, int)
+     * }
+     */
+    public static final AddressLayout setxattr$layout() {
+        return setxattr$LAYOUT;
+    }
+
+    private static final long setxattr$OFFSET = 168;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*setxattr)(const char *, const char *, const char *, size_t, int)
+     * }
+     */
+    public static final long setxattr$offset() {
+        return setxattr$OFFSET;
+    }
+
+    /**
+     * Getter for field:
+     * {@snippet lang=c :
+     * int (*setxattr)(const char *, const char *, const char *, size_t, int)
+     * }
+     */
+    public static MemorySegment setxattr(MemorySegment struct) {
+        return struct.get(setxattr$LAYOUT, setxattr$OFFSET);
+    }
+
+    /**
+     * Setter for field:
+     * {@snippet lang=c :
+     * int (*setxattr)(const char *, const char *, const char *, size_t, int)
+     * }
+     */
+    public static void setxattr(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(setxattr$LAYOUT, setxattr$OFFSET, fieldValue);
+    }
+
+    /**
+     * {@snippet lang=c :
+     * int (*getxattr)(const char *, const char *, char *, size_t)
+     * }
+     */
+    public static class getxattr {
+
+        getxattr() {
+            // Should not be called directly
+        }
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, MemorySegment _x1, MemorySegment _x2, long _x3);
+        }
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER,
+            fuse_h.C_LONG
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(getxattr.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(getxattr.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1, MemorySegment _x2, long _x3) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2, _x3);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
+    }
+
+    private static final AddressLayout getxattr$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("getxattr"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*getxattr)(const char *, const char *, char *, size_t)
+     * }
+     */
+    public static final AddressLayout getxattr$layout() {
+        return getxattr$LAYOUT;
+    }
+
+    private static final long getxattr$OFFSET = 176;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*getxattr)(const char *, const char *, char *, size_t)
+     * }
+     */
+    public static final long getxattr$offset() {
+        return getxattr$OFFSET;
+    }
+
+    /**
+     * Getter for field:
+     * {@snippet lang=c :
+     * int (*getxattr)(const char *, const char *, char *, size_t)
+     * }
+     */
+    public static MemorySegment getxattr(MemorySegment struct) {
+        return struct.get(getxattr$LAYOUT, getxattr$OFFSET);
+    }
+
+    /**
+     * Setter for field:
+     * {@snippet lang=c :
+     * int (*getxattr)(const char *, const char *, char *, size_t)
+     * }
+     */
+    public static void getxattr(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(getxattr$LAYOUT, getxattr$OFFSET, fieldValue);
+    }
+
+    /**
+     * {@snippet lang=c :
+     * int (*listxattr)(const char *, char *, size_t)
+     * }
+     */
+    public static class listxattr {
+
+        listxattr() {
+            // Should not be called directly
+        }
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, MemorySegment _x1, long _x2);
+        }
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER,
+            fuse_h.C_LONG
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(listxattr.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(listxattr.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1, long _x2) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
+    }
+
+    private static final AddressLayout listxattr$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("listxattr"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*listxattr)(const char *, char *, size_t)
+     * }
+     */
+    public static final AddressLayout listxattr$layout() {
+        return listxattr$LAYOUT;
+    }
+
+    private static final long listxattr$OFFSET = 184;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*listxattr)(const char *, char *, size_t)
+     * }
+     */
+    public static final long listxattr$offset() {
+        return listxattr$OFFSET;
+    }
+
+    /**
+     * Getter for field:
+     * {@snippet lang=c :
+     * int (*listxattr)(const char *, char *, size_t)
+     * }
+     */
+    public static MemorySegment listxattr(MemorySegment struct) {
+        return struct.get(listxattr$LAYOUT, listxattr$OFFSET);
+    }
+
+    /**
+     * Setter for field:
+     * {@snippet lang=c :
+     * int (*listxattr)(const char *, char *, size_t)
+     * }
+     */
+    public static void listxattr(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(listxattr$LAYOUT, listxattr$OFFSET, fieldValue);
+    }
+
+    /**
+     * {@snippet lang=c :
+     * int (*removexattr)(const char *, const char *)
+     * }
+     */
+    public static class removexattr {
+
+        removexattr() {
+            // Should not be called directly
+        }
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, MemorySegment _x1);
+        }
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(removexattr.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(removexattr.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
+    }
+
+    private static final AddressLayout removexattr$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("removexattr"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*removexattr)(const char *, const char *)
+     * }
+     */
+    public static final AddressLayout removexattr$layout() {
+        return removexattr$LAYOUT;
+    }
+
+    private static final long removexattr$OFFSET = 192;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*removexattr)(const char *, const char *)
+     * }
+     */
+    public static final long removexattr$offset() {
+        return removexattr$OFFSET;
+    }
+
+    /**
+     * Getter for field:
+     * {@snippet lang=c :
+     * int (*removexattr)(const char *, const char *)
+     * }
+     */
+    public static MemorySegment removexattr(MemorySegment struct) {
+        return struct.get(removexattr$LAYOUT, removexattr$OFFSET);
+    }
+
+    /**
+     * Setter for field:
+     * {@snippet lang=c :
+     * int (*removexattr)(const char *, const char *)
+     * }
+     */
+    public static void removexattr(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(removexattr$LAYOUT, removexattr$OFFSET, fieldValue);
+    }
+
+    /**
+     * {@snippet lang=c :
+     * int (*opendir)(const char *, struct fuse_file_info *)
+     * }
+     */
+    public static class opendir {
+
+        opendir() {
+            // Should not be called directly
+        }
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, MemorySegment _x1);
+        }
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(opendir.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(opendir.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
+    }
+
+    private static final AddressLayout opendir$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("opendir"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*opendir)(const char *, struct fuse_file_info *)
+     * }
+     */
+    public static final AddressLayout opendir$layout() {
+        return opendir$LAYOUT;
+    }
+
+    private static final long opendir$OFFSET = 200;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*opendir)(const char *, struct fuse_file_info *)
+     * }
+     */
+    public static final long opendir$offset() {
+        return opendir$OFFSET;
+    }
+
+    /**
+     * Getter for field:
+     * {@snippet lang=c :
+     * int (*opendir)(const char *, struct fuse_file_info *)
+     * }
+     */
+    public static MemorySegment opendir(MemorySegment struct) {
+        return struct.get(opendir$LAYOUT, opendir$OFFSET);
+    }
+
+    /**
+     * Setter for field:
+     * {@snippet lang=c :
+     * int (*opendir)(const char *, struct fuse_file_info *)
+     * }
+     */
+    public static void opendir(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(opendir$LAYOUT, opendir$OFFSET, fieldValue);
+    }
+
+    /**
+     * {@snippet lang=c :
+     * int (*readdir)(const char *, void *, fuse_fill_dir_t, off_t, struct fuse_file_info *)
+     * }
+     */
+    public static class readdir {
+
+        readdir() {
+            // Should not be called directly
+        }
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, MemorySegment _x1, MemorySegment _x2, long _x3, MemorySegment _x4);
+        }
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER,
+            fuse_h.C_LONG_LONG,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(readdir.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(readdir.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1, MemorySegment _x2, long _x3, MemorySegment _x4) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2, _x3, _x4);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
+    }
+
+    private static final AddressLayout readdir$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("readdir"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*readdir)(const char *, void *, fuse_fill_dir_t, off_t, struct fuse_file_info *)
+     * }
+     */
+    public static final AddressLayout readdir$layout() {
+        return readdir$LAYOUT;
+    }
+
+    private static final long readdir$OFFSET = 208;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*readdir)(const char *, void *, fuse_fill_dir_t, off_t, struct fuse_file_info *)
+     * }
+     */
+    public static final long readdir$offset() {
+        return readdir$OFFSET;
+    }
+
+    /**
+     * Getter for field:
+     * {@snippet lang=c :
+     * int (*readdir)(const char *, void *, fuse_fill_dir_t, off_t, struct fuse_file_info *)
+     * }
+     */
+    public static MemorySegment readdir(MemorySegment struct) {
+        return struct.get(readdir$LAYOUT, readdir$OFFSET);
+    }
+
+    /**
+     * Setter for field:
+     * {@snippet lang=c :
+     * int (*readdir)(const char *, void *, fuse_fill_dir_t, off_t, struct fuse_file_info *)
+     * }
+     */
+    public static void readdir(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(readdir$LAYOUT, readdir$OFFSET, fieldValue);
+    }
+
+    /**
+     * {@snippet lang=c :
+     * int (*releasedir)(const char *, struct fuse_file_info *)
+     * }
+     */
+    public static class releasedir {
+
+        releasedir() {
+            // Should not be called directly
+        }
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, MemorySegment _x1);
+        }
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(releasedir.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(releasedir.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
+    }
+
+    private static final AddressLayout releasedir$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("releasedir"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*releasedir)(const char *, struct fuse_file_info *)
+     * }
+     */
+    public static final AddressLayout releasedir$layout() {
+        return releasedir$LAYOUT;
+    }
+
+    private static final long releasedir$OFFSET = 216;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*releasedir)(const char *, struct fuse_file_info *)
+     * }
+     */
+    public static final long releasedir$offset() {
+        return releasedir$OFFSET;
+    }
+
+    /**
+     * Getter for field:
+     * {@snippet lang=c :
+     * int (*releasedir)(const char *, struct fuse_file_info *)
+     * }
+     */
+    public static MemorySegment releasedir(MemorySegment struct) {
+        return struct.get(releasedir$LAYOUT, releasedir$OFFSET);
+    }
+
+    /**
+     * Setter for field:
+     * {@snippet lang=c :
+     * int (*releasedir)(const char *, struct fuse_file_info *)
+     * }
+     */
+    public static void releasedir(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(releasedir$LAYOUT, releasedir$OFFSET, fieldValue);
+    }
+
+    /**
+     * {@snippet lang=c :
+     * int (*fsyncdir)(const char *, int, struct fuse_file_info *)
+     * }
+     */
+    public static class fsyncdir {
+
+        fsyncdir() {
+            // Should not be called directly
+        }
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, int _x1, MemorySegment _x2);
+        }
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_INT,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(fsyncdir.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(fsyncdir.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, int _x1, MemorySegment _x2) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
+    }
+
+    private static final AddressLayout fsyncdir$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("fsyncdir"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*fsyncdir)(const char *, int, struct fuse_file_info *)
+     * }
+     */
+    public static final AddressLayout fsyncdir$layout() {
+        return fsyncdir$LAYOUT;
+    }
+
+    private static final long fsyncdir$OFFSET = 224;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*fsyncdir)(const char *, int, struct fuse_file_info *)
+     * }
+     */
+    public static final long fsyncdir$offset() {
+        return fsyncdir$OFFSET;
+    }
+
+    /**
+     * Getter for field:
+     * {@snippet lang=c :
+     * int (*fsyncdir)(const char *, int, struct fuse_file_info *)
+     * }
+     */
+    public static MemorySegment fsyncdir(MemorySegment struct) {
+        return struct.get(fsyncdir$LAYOUT, fsyncdir$OFFSET);
+    }
+
+    /**
+     * Setter for field:
+     * {@snippet lang=c :
+     * int (*fsyncdir)(const char *, int, struct fuse_file_info *)
+     * }
+     */
+    public static void fsyncdir(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(fsyncdir$LAYOUT, fsyncdir$OFFSET, fieldValue);
+    }
+
+    /**
+     * {@snippet lang=c :
+     * void *(*init)(struct fuse_conn_info *)
+     * }
+     */
+    public static class init {
+
+        init() {
+            // Should not be called directly
+        }
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            MemorySegment apply(MemorySegment _x0);
+        }
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(init.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(init.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static MemorySegment invoke(MemorySegment funcPtr,MemorySegment _x0) {
+            try {
+                return (MemorySegment) DOWN$MH.invokeExact(funcPtr, _x0);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
+    }
+
+    private static final AddressLayout init$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("init"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * void *(*init)(struct fuse_conn_info *)
+     * }
+     */
+    public static final AddressLayout init$layout() {
+        return init$LAYOUT;
+    }
+
+    private static final long init$OFFSET = 232;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * void *(*init)(struct fuse_conn_info *)
+     * }
+     */
+    public static final long init$offset() {
+        return init$OFFSET;
+    }
+
+    /**
+     * Getter for field:
+     * {@snippet lang=c :
+     * void *(*init)(struct fuse_conn_info *)
+     * }
+     */
+    public static MemorySegment init(MemorySegment struct) {
+        return struct.get(init$LAYOUT, init$OFFSET);
+    }
+
+    /**
+     * Setter for field:
+     * {@snippet lang=c :
+     * void *(*init)(struct fuse_conn_info *)
+     * }
+     */
+    public static void init(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(init$LAYOUT, init$OFFSET, fieldValue);
+    }
+
+    /**
+     * {@snippet lang=c :
+     * void (*destroy)(void *)
+     * }
+     */
+    public static class destroy {
+
+        destroy() {
+            // Should not be called directly
+        }
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            void apply(MemorySegment _x0);
+        }
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.ofVoid(
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(destroy.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(destroy.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static void invoke(MemorySegment funcPtr,MemorySegment _x0) {
+            try {
+                 DOWN$MH.invokeExact(funcPtr, _x0);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
     }
-    public static releasedir releasedir(MemorySegment segment, Arena scope) {
-        return releasedir.ofAddress(releasedir$get(segment), scope);
+
+    private static final AddressLayout destroy$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("destroy"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * void (*destroy)(void *)
+     * }
+     */
+    public static final AddressLayout destroy$layout() {
+        return destroy$LAYOUT;
+    }
+
+    private static final long destroy$OFFSET = 240;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * void (*destroy)(void *)
+     * }
+     */
+    public static final long destroy$offset() {
+        return destroy$OFFSET;
+    }
+
+    /**
+     * Getter for field:
+     * {@snippet lang=c :
+     * void (*destroy)(void *)
+     * }
+     */
+    public static MemorySegment destroy(MemorySegment struct) {
+        return struct.get(destroy$LAYOUT, destroy$OFFSET);
+    }
+
+    /**
+     * Setter for field:
+     * {@snippet lang=c :
+     * void (*destroy)(void *)
+     * }
+     */
+    public static void destroy(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(destroy$LAYOUT, destroy$OFFSET, fieldValue);
+    }
+
+    /**
+     * {@snippet lang=c :
+     * int (*access)(const char *, int)
+     * }
+     */
+    public static class access {
+
+        access() {
+            // Should not be called directly
+        }
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, int _x1);
+        }
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_INT
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(access.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(access.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, int _x1) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
+    }
+
+    private static final AddressLayout access$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("access"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*access)(const char *, int)
+     * }
+     */
+    public static final AddressLayout access$layout() {
+        return access$LAYOUT;
+    }
+
+    private static final long access$OFFSET = 248;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*access)(const char *, int)
+     * }
+     */
+    public static final long access$offset() {
+        return access$OFFSET;
+    }
+
+    /**
+     * Getter for field:
+     * {@snippet lang=c :
+     * int (*access)(const char *, int)
+     * }
+     */
+    public static MemorySegment access(MemorySegment struct) {
+        return struct.get(access$LAYOUT, access$OFFSET);
+    }
+
+    /**
+     * Setter for field:
+     * {@snippet lang=c :
+     * int (*access)(const char *, int)
+     * }
+     */
+    public static void access(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(access$LAYOUT, access$OFFSET, fieldValue);
+    }
+
+    /**
+     * {@snippet lang=c :
+     * int (*create)(const char *, mode_t, struct fuse_file_info *)
+     * }
+     */
+    public static class create {
+
+        create() {
+            // Should not be called directly
+        }
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, short _x1, MemorySegment _x2);
+        }
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_SHORT,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(create.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(create.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, short _x1, MemorySegment _x2) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
+    }
+
+    private static final AddressLayout create$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("create"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*create)(const char *, mode_t, struct fuse_file_info *)
+     * }
+     */
+    public static final AddressLayout create$layout() {
+        return create$LAYOUT;
+    }
+
+    private static final long create$OFFSET = 256;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*create)(const char *, mode_t, struct fuse_file_info *)
+     * }
+     */
+    public static final long create$offset() {
+        return create$OFFSET;
+    }
+
+    /**
+     * Getter for field:
+     * {@snippet lang=c :
+     * int (*create)(const char *, mode_t, struct fuse_file_info *)
+     * }
+     */
+    public static MemorySegment create(MemorySegment struct) {
+        return struct.get(create$LAYOUT, create$OFFSET);
+    }
+
+    /**
+     * Setter for field:
+     * {@snippet lang=c :
+     * int (*create)(const char *, mode_t, struct fuse_file_info *)
+     * }
+     */
+    public static void create(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(create$LAYOUT, create$OFFSET, fieldValue);
+    }
+
+    /**
+     * {@snippet lang=c :
+     * int (*ftruncate)(const char *, off_t, struct fuse_file_info *)
+     * }
+     */
+    public static class ftruncate {
+
+        ftruncate() {
+            // Should not be called directly
+        }
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, long _x1, MemorySegment _x2);
+        }
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_LONG_LONG,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(ftruncate.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(ftruncate.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, long _x1, MemorySegment _x2) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
+    }
+
+    private static final AddressLayout ftruncate$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("ftruncate"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*ftruncate)(const char *, off_t, struct fuse_file_info *)
+     * }
+     */
+    public static final AddressLayout ftruncate$layout() {
+        return ftruncate$LAYOUT;
+    }
+
+    private static final long ftruncate$OFFSET = 264;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*ftruncate)(const char *, off_t, struct fuse_file_info *)
+     * }
+     */
+    public static final long ftruncate$offset() {
+        return ftruncate$OFFSET;
+    }
+
+    /**
+     * Getter for field:
+     * {@snippet lang=c :
+     * int (*ftruncate)(const char *, off_t, struct fuse_file_info *)
+     * }
+     */
+    public static MemorySegment ftruncate(MemorySegment struct) {
+        return struct.get(ftruncate$LAYOUT, ftruncate$OFFSET);
+    }
+
+    /**
+     * Setter for field:
+     * {@snippet lang=c :
+     * int (*ftruncate)(const char *, off_t, struct fuse_file_info *)
+     * }
+     */
+    public static void ftruncate(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(ftruncate$LAYOUT, ftruncate$OFFSET, fieldValue);
+    }
+
+    /**
+     * {@snippet lang=c :
+     * int (*fgetattr)(const char *, struct stat *, struct fuse_file_info *)
+     * }
+     */
+    public static class fgetattr {
+
+        fgetattr() {
+            // Should not be called directly
+        }
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, MemorySegment _x1, MemorySegment _x2);
+        }
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(fgetattr.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(fgetattr.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1, MemorySegment _x2) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
+    }
+
+    private static final AddressLayout fgetattr$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("fgetattr"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*fgetattr)(const char *, struct stat *, struct fuse_file_info *)
+     * }
+     */
+    public static final AddressLayout fgetattr$layout() {
+        return fgetattr$LAYOUT;
+    }
+
+    private static final long fgetattr$OFFSET = 272;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*fgetattr)(const char *, struct stat *, struct fuse_file_info *)
+     * }
+     */
+    public static final long fgetattr$offset() {
+        return fgetattr$OFFSET;
+    }
+
+    /**
+     * Getter for field:
+     * {@snippet lang=c :
+     * int (*fgetattr)(const char *, struct stat *, struct fuse_file_info *)
+     * }
+     */
+    public static MemorySegment fgetattr(MemorySegment struct) {
+        return struct.get(fgetattr$LAYOUT, fgetattr$OFFSET);
+    }
+
+    /**
+     * Setter for field:
+     * {@snippet lang=c :
+     * int (*fgetattr)(const char *, struct stat *, struct fuse_file_info *)
+     * }
+     */
+    public static void fgetattr(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(fgetattr$LAYOUT, fgetattr$OFFSET, fieldValue);
+    }
+
+    /**
+     * {@snippet lang=c :
+     * int (*lock)(const char *, struct fuse_file_info *, int, struct flock *)
+     * }
+     */
+    public static class lock {
+
+        lock() {
+            // Should not be called directly
+        }
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, MemorySegment _x1, int _x2, MemorySegment _x3);
+        }
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER,
+            fuse_h.C_INT,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(lock.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(lock.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1, int _x2, MemorySegment _x3) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2, _x3);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
+    }
+
+    private static final AddressLayout lock$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("lock"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*lock)(const char *, struct fuse_file_info *, int, struct flock *)
+     * }
+     */
+    public static final AddressLayout lock$layout() {
+        return lock$LAYOUT;
+    }
+
+    private static final long lock$OFFSET = 280;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*lock)(const char *, struct fuse_file_info *, int, struct flock *)
+     * }
+     */
+    public static final long lock$offset() {
+        return lock$OFFSET;
+    }
+
+    /**
+     * Getter for field:
+     * {@snippet lang=c :
+     * int (*lock)(const char *, struct fuse_file_info *, int, struct flock *)
+     * }
+     */
+    public static MemorySegment lock(MemorySegment struct) {
+        return struct.get(lock$LAYOUT, lock$OFFSET);
+    }
+
+    /**
+     * Setter for field:
+     * {@snippet lang=c :
+     * int (*lock)(const char *, struct fuse_file_info *, int, struct flock *)
+     * }
+     */
+    public static void lock(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(lock$LAYOUT, lock$OFFSET, fieldValue);
+    }
+
+    /**
+     * {@snippet lang=c :
+     * int (*utimens)(const char *, const struct timespec *)
+     * }
+     */
+    public static class utimens {
+
+        utimens() {
+            // Should not be called directly
+        }
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, MemorySegment _x1);
+        }
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(utimens.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(utimens.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
+    }
+
+    private static final AddressLayout utimens$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("utimens"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*utimens)(const char *, const struct timespec *)
+     * }
+     */
+    public static final AddressLayout utimens$layout() {
+        return utimens$LAYOUT;
     }
+
+    private static final long utimens$OFFSET = 288;
+
     /**
-     * {@snippet :
- * int (*fsyncdir)(char*,int,struct fuse_file_info*);
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*utimens)(const char *, const struct timespec *)
      * }
      */
-    public interface fsyncdir {
-
-        int apply(java.lang.foreign.MemorySegment _x0, int _x1, java.lang.foreign.MemorySegment _x2);
-        static MemorySegment allocate(fsyncdir fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$23.const$1, fi, constants$19.const$3, scope);
-        }
-        static fsyncdir ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, int __x1, java.lang.foreign.MemorySegment __x2) -> {
-                try {
-                    return (int)constants$19.const$5.invokeExact(symbol, __x0, __x1, __x2);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
-        }
+    public static final long utimens$offset() {
+        return utimens$OFFSET;
     }
 
-    public static VarHandle fsyncdir$VH() {
-        return constants$23.const$2;
-    }
     /**
      * Getter for field:
-     * {@snippet :
-     * int (*fsyncdir)(char*,int,struct fuse_file_info*);
+     * {@snippet lang=c :
+     * int (*utimens)(const char *, const struct timespec *)
      * }
      */
-    public static MemorySegment fsyncdir$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$23.const$2.get(seg);
+    public static MemorySegment utimens(MemorySegment struct) {
+        return struct.get(utimens$LAYOUT, utimens$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int (*fsyncdir)(char*,int,struct fuse_file_info*);
+     * {@snippet lang=c :
+     * int (*utimens)(const char *, const struct timespec *)
      * }
      */
-    public static void fsyncdir$set(MemorySegment seg, MemorySegment x) {
-        constants$23.const$2.set(seg, x);
-    }
-    public static MemorySegment fsyncdir$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$23.const$2.get(seg.asSlice(index*sizeof()));
-    }
-    public static void fsyncdir$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$23.const$2.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static fsyncdir fsyncdir(MemorySegment segment, Arena scope) {
-        return fsyncdir.ofAddress(fsyncdir$get(segment), scope);
+    public static void utimens(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(utimens$LAYOUT, utimens$OFFSET, fieldValue);
     }
+
     /**
-     * {@snippet :
- * void* (*init)(struct fuse_conn_info*);
+     * {@snippet lang=c :
+     * int (*bmap)(const char *, size_t, uint64_t *)
      * }
      */
-    public interface init {
+    public static class bmap {
 
-        java.lang.foreign.MemorySegment apply(java.lang.foreign.MemorySegment _x0);
-        static MemorySegment allocate(init fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$23.const$4, fi, constants$23.const$3, scope);
+        bmap() {
+            // Should not be called directly
         }
-        static init ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0) -> {
-                try {
-                    return (java.lang.foreign.MemorySegment)constants$23.const$5.invokeExact(symbol, __x0);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, long _x1, MemorySegment _x2);
         }
-    }
 
-    public static VarHandle init$VH() {
-        return constants$24.const$0;
-    }
-    /**
-     * Getter for field:
-     * {@snippet :
-     * void* (*init)(struct fuse_conn_info*);
-     * }
-     */
-    public static MemorySegment init$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$24.const$0.get(seg);
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_LONG,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(bmap.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(bmap.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, long _x1, MemorySegment _x2) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
     }
+
+    private static final AddressLayout bmap$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("bmap"));
+
     /**
-     * Setter for field:
-     * {@snippet :
-     * void* (*init)(struct fuse_conn_info*);
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*bmap)(const char *, size_t, uint64_t *)
      * }
      */
-    public static void init$set(MemorySegment seg, MemorySegment x) {
-        constants$24.const$0.set(seg, x);
-    }
-    public static MemorySegment init$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$24.const$0.get(seg.asSlice(index*sizeof()));
-    }
-    public static void init$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$24.const$0.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static init init(MemorySegment segment, Arena scope) {
-        return init.ofAddress(init$get(segment), scope);
+    public static final AddressLayout bmap$layout() {
+        return bmap$LAYOUT;
     }
+
+    private static final long bmap$OFFSET = 296;
+
     /**
-     * {@snippet :
- * void (*destroy)(void*);
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*bmap)(const char *, size_t, uint64_t *)
      * }
      */
-    public interface destroy {
-
-        void apply(java.lang.foreign.MemorySegment _x0);
-        static MemorySegment allocate(destroy fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$24.const$2, fi, constants$24.const$1, scope);
-        }
-        static destroy ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0) -> {
-                try {
-                    constants$24.const$3.invokeExact(symbol, __x0);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
-        }
+    public static final long bmap$offset() {
+        return bmap$OFFSET;
     }
 
-    public static VarHandle destroy$VH() {
-        return constants$24.const$4;
-    }
     /**
      * Getter for field:
-     * {@snippet :
-     * void (*destroy)(void*);
+     * {@snippet lang=c :
+     * int (*bmap)(const char *, size_t, uint64_t *)
      * }
      */
-    public static MemorySegment destroy$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$24.const$4.get(seg);
+    public static MemorySegment bmap(MemorySegment struct) {
+        return struct.get(bmap$LAYOUT, bmap$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * void (*destroy)(void*);
+     * {@snippet lang=c :
+     * int (*bmap)(const char *, size_t, uint64_t *)
      * }
      */
-    public static void destroy$set(MemorySegment seg, MemorySegment x) {
-        constants$24.const$4.set(seg, x);
-    }
-    public static MemorySegment destroy$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$24.const$4.get(seg.asSlice(index*sizeof()));
-    }
-    public static void destroy$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$24.const$4.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static destroy destroy(MemorySegment segment, Arena scope) {
-        return destroy.ofAddress(destroy$get(segment), scope);
+    public static void bmap(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(bmap$LAYOUT, bmap$OFFSET, fieldValue);
     }
+
     /**
-     * {@snippet :
- * int (*access)(char*,int);
+     * {@snippet lang=c :
+     * int (*ioctl)(const char *, int, void *, struct fuse_file_info *, unsigned int, void *)
      * }
      */
-    public interface access {
+    public static class ioctl {
 
-        int apply(java.lang.foreign.MemorySegment _x0, int _x1);
-        static MemorySegment allocate(access fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$25.const$0, fi, constants$24.const$5, scope);
+        ioctl() {
+            // Should not be called directly
         }
-        static access ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, int __x1) -> {
-                try {
-                    return (int)constants$25.const$1.invokeExact(symbol, __x0, __x1);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, int _x1, MemorySegment _x2, MemorySegment _x3, int _x4, MemorySegment _x5);
         }
-    }
 
-    public static VarHandle access$VH() {
-        return constants$25.const$2;
-    }
-    /**
-     * Getter for field:
-     * {@snippet :
-     * int (*access)(char*,int);
-     * }
-     */
-    public static MemorySegment access$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$25.const$2.get(seg);
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER,
+            fuse_h.C_INT,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(ioctl.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(ioctl.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, int _x1, MemorySegment _x2, MemorySegment _x3, int _x4, MemorySegment _x5) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2, _x3, _x4, _x5);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
     }
+
+    private static final AddressLayout ioctl$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("ioctl"));
+
     /**
-     * Setter for field:
-     * {@snippet :
-     * int (*access)(char*,int);
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*ioctl)(const char *, int, void *, struct fuse_file_info *, unsigned int, void *)
      * }
      */
-    public static void access$set(MemorySegment seg, MemorySegment x) {
-        constants$25.const$2.set(seg, x);
-    }
-    public static MemorySegment access$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$25.const$2.get(seg.asSlice(index*sizeof()));
-    }
-    public static void access$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$25.const$2.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static access access(MemorySegment segment, Arena scope) {
-        return access.ofAddress(access$get(segment), scope);
+    public static final AddressLayout ioctl$layout() {
+        return ioctl$LAYOUT;
     }
+
+    private static final long ioctl$OFFSET = 312;
+
     /**
-     * {@snippet :
- * int (*create)(char*,mode_t,struct fuse_file_info*);
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*ioctl)(const char *, int, void *, struct fuse_file_info *, unsigned int, void *)
      * }
      */
-    public interface create {
-
-        int apply(java.lang.foreign.MemorySegment _x0, short _x1, java.lang.foreign.MemorySegment _x2);
-        static MemorySegment allocate(create fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$25.const$4, fi, constants$25.const$3, scope);
-        }
-        static create ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, short __x1, java.lang.foreign.MemorySegment __x2) -> {
-                try {
-                    return (int)constants$25.const$5.invokeExact(symbol, __x0, __x1, __x2);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
-        }
+    public static final long ioctl$offset() {
+        return ioctl$OFFSET;
     }
 
-    public static VarHandle create$VH() {
-        return constants$26.const$0;
-    }
     /**
      * Getter for field:
-     * {@snippet :
-     * int (*create)(char*,mode_t,struct fuse_file_info*);
+     * {@snippet lang=c :
+     * int (*ioctl)(const char *, int, void *, struct fuse_file_info *, unsigned int, void *)
      * }
      */
-    public static MemorySegment create$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$26.const$0.get(seg);
+    public static MemorySegment ioctl(MemorySegment struct) {
+        return struct.get(ioctl$LAYOUT, ioctl$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int (*create)(char*,mode_t,struct fuse_file_info*);
+     * {@snippet lang=c :
+     * int (*ioctl)(const char *, int, void *, struct fuse_file_info *, unsigned int, void *)
      * }
      */
-    public static void create$set(MemorySegment seg, MemorySegment x) {
-        constants$26.const$0.set(seg, x);
-    }
-    public static MemorySegment create$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$26.const$0.get(seg.asSlice(index*sizeof()));
-    }
-    public static void create$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$26.const$0.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static create create(MemorySegment segment, Arena scope) {
-        return create.ofAddress(create$get(segment), scope);
+    public static void ioctl(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(ioctl$LAYOUT, ioctl$OFFSET, fieldValue);
     }
+
     /**
-     * {@snippet :
- * int (*ftruncate)(char*,off_t,struct fuse_file_info*);
+     * {@snippet lang=c :
+     * int (*poll)(const char *, struct fuse_file_info *, struct fuse_pollhandle *, unsigned int *)
      * }
      */
-    public interface ftruncate {
+    public static class poll {
 
-        int apply(java.lang.foreign.MemorySegment _x0, long _x1, java.lang.foreign.MemorySegment _x2);
-        static MemorySegment allocate(ftruncate fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$26.const$2, fi, constants$26.const$1, scope);
+        poll() {
+            // Should not be called directly
         }
-        static ftruncate ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, long __x1, java.lang.foreign.MemorySegment __x2) -> {
-                try {
-                    return (int)constants$26.const$3.invokeExact(symbol, __x0, __x1, __x2);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, MemorySegment _x1, MemorySegment _x2, MemorySegment _x3);
         }
-    }
 
-    public static VarHandle ftruncate$VH() {
-        return constants$26.const$4;
-    }
-    /**
-     * Getter for field:
-     * {@snippet :
-     * int (*ftruncate)(char*,off_t,struct fuse_file_info*);
-     * }
-     */
-    public static MemorySegment ftruncate$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$26.const$4.get(seg);
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(poll.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(poll.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1, MemorySegment _x2, MemorySegment _x3) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2, _x3);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
     }
+
+    private static final AddressLayout poll$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("poll"));
+
     /**
-     * Setter for field:
-     * {@snippet :
-     * int (*ftruncate)(char*,off_t,struct fuse_file_info*);
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*poll)(const char *, struct fuse_file_info *, struct fuse_pollhandle *, unsigned int *)
      * }
      */
-    public static void ftruncate$set(MemorySegment seg, MemorySegment x) {
-        constants$26.const$4.set(seg, x);
-    }
-    public static MemorySegment ftruncate$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$26.const$4.get(seg.asSlice(index*sizeof()));
-    }
-    public static void ftruncate$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$26.const$4.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static ftruncate ftruncate(MemorySegment segment, Arena scope) {
-        return ftruncate.ofAddress(ftruncate$get(segment), scope);
+    public static final AddressLayout poll$layout() {
+        return poll$LAYOUT;
     }
+
+    private static final long poll$OFFSET = 320;
+
     /**
-     * {@snippet :
- * int (*fgetattr)(char*,struct stat*,struct fuse_file_info*);
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*poll)(const char *, struct fuse_file_info *, struct fuse_pollhandle *, unsigned int *)
      * }
      */
-    public interface fgetattr {
-
-        int apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1, java.lang.foreign.MemorySegment _x2);
-        static MemorySegment allocate(fgetattr fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$26.const$5, fi, constants$11.const$1, scope);
-        }
-        static fgetattr ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1, java.lang.foreign.MemorySegment __x2) -> {
-                try {
-                    return (int)constants$11.const$3.invokeExact(symbol, __x0, __x1, __x2);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
-        }
+    public static final long poll$offset() {
+        return poll$OFFSET;
     }
 
-    public static VarHandle fgetattr$VH() {
-        return constants$27.const$0;
-    }
     /**
      * Getter for field:
-     * {@snippet :
-     * int (*fgetattr)(char*,struct stat*,struct fuse_file_info*);
+     * {@snippet lang=c :
+     * int (*poll)(const char *, struct fuse_file_info *, struct fuse_pollhandle *, unsigned int *)
      * }
      */
-    public static MemorySegment fgetattr$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$27.const$0.get(seg);
+    public static MemorySegment poll(MemorySegment struct) {
+        return struct.get(poll$LAYOUT, poll$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int (*fgetattr)(char*,struct stat*,struct fuse_file_info*);
+     * {@snippet lang=c :
+     * int (*poll)(const char *, struct fuse_file_info *, struct fuse_pollhandle *, unsigned int *)
      * }
      */
-    public static void fgetattr$set(MemorySegment seg, MemorySegment x) {
-        constants$27.const$0.set(seg, x);
-    }
-    public static MemorySegment fgetattr$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$27.const$0.get(seg.asSlice(index*sizeof()));
-    }
-    public static void fgetattr$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$27.const$0.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static fgetattr fgetattr(MemorySegment segment, Arena scope) {
-        return fgetattr.ofAddress(fgetattr$get(segment), scope);
+    public static void poll(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(poll$LAYOUT, poll$OFFSET, fieldValue);
     }
+
     /**
-     * {@snippet :
- * int (*lock)(char*,struct fuse_file_info*,int,struct flock*);
+     * {@snippet lang=c :
+     * int (*write_buf)(const char *, struct fuse_bufvec *, off_t, struct fuse_file_info *)
      * }
      */
-    public interface lock {
+    public static class write_buf {
 
-        int apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1, int _x2, java.lang.foreign.MemorySegment _x3);
-        static MemorySegment allocate(lock fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$27.const$2, fi, constants$27.const$1, scope);
+        write_buf() {
+            // Should not be called directly
         }
-        static lock ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1, int __x2, java.lang.foreign.MemorySegment __x3) -> {
-                try {
-                    return (int)constants$27.const$3.invokeExact(symbol, __x0, __x1, __x2, __x3);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, MemorySegment _x1, long _x2, MemorySegment _x3);
         }
-    }
 
-    public static VarHandle lock$VH() {
-        return constants$27.const$4;
-    }
-    /**
-     * Getter for field:
-     * {@snippet :
-     * int (*lock)(char*,struct fuse_file_info*,int,struct flock*);
-     * }
-     */
-    public static MemorySegment lock$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$27.const$4.get(seg);
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER,
+            fuse_h.C_LONG_LONG,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(write_buf.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(write_buf.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1, long _x2, MemorySegment _x3) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2, _x3);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
     }
+
+    private static final AddressLayout write_buf$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("write_buf"));
+
     /**
-     * Setter for field:
-     * {@snippet :
-     * int (*lock)(char*,struct fuse_file_info*,int,struct flock*);
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*write_buf)(const char *, struct fuse_bufvec *, off_t, struct fuse_file_info *)
      * }
      */
-    public static void lock$set(MemorySegment seg, MemorySegment x) {
-        constants$27.const$4.set(seg, x);
-    }
-    public static MemorySegment lock$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$27.const$4.get(seg.asSlice(index*sizeof()));
-    }
-    public static void lock$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$27.const$4.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static lock lock(MemorySegment segment, Arena scope) {
-        return lock.ofAddress(lock$get(segment), scope);
+    public static final AddressLayout write_buf$layout() {
+        return write_buf$LAYOUT;
     }
+
+    private static final long write_buf$OFFSET = 328;
+
     /**
-     * {@snippet :
- * int (*utimens)(char*,struct timespec*);
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*write_buf)(const char *, struct fuse_bufvec *, off_t, struct fuse_file_info *)
      * }
      */
-    public interface utimens {
-
-        int apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1);
-        static MemorySegment allocate(utimens fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$27.const$5, fi, constants$9.const$5, scope);
-        }
-        static utimens ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1) -> {
-                try {
-                    return (int)constants$10.const$1.invokeExact(symbol, __x0, __x1);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
-        }
+    public static final long write_buf$offset() {
+        return write_buf$OFFSET;
     }
 
-    public static VarHandle utimens$VH() {
-        return constants$28.const$0;
-    }
     /**
      * Getter for field:
-     * {@snippet :
-     * int (*utimens)(char*,struct timespec*);
+     * {@snippet lang=c :
+     * int (*write_buf)(const char *, struct fuse_bufvec *, off_t, struct fuse_file_info *)
      * }
      */
-    public static MemorySegment utimens$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$28.const$0.get(seg);
+    public static MemorySegment write_buf(MemorySegment struct) {
+        return struct.get(write_buf$LAYOUT, write_buf$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int (*utimens)(char*,struct timespec*);
+     * {@snippet lang=c :
+     * int (*write_buf)(const char *, struct fuse_bufvec *, off_t, struct fuse_file_info *)
      * }
      */
-    public static void utimens$set(MemorySegment seg, MemorySegment x) {
-        constants$28.const$0.set(seg, x);
-    }
-    public static MemorySegment utimens$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$28.const$0.get(seg.asSlice(index*sizeof()));
-    }
-    public static void utimens$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$28.const$0.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static utimens utimens(MemorySegment segment, Arena scope) {
-        return utimens.ofAddress(utimens$get(segment), scope);
+    public static void write_buf(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(write_buf$LAYOUT, write_buf$OFFSET, fieldValue);
     }
+
     /**
-     * {@snippet :
- * int (*bmap)(char*,size_t,uint64_t*);
+     * {@snippet lang=c :
+     * int (*read_buf)(const char *, struct fuse_bufvec **, size_t, off_t, struct fuse_file_info *)
      * }
      */
-    public interface bmap {
+    public static class read_buf {
 
-        int apply(java.lang.foreign.MemorySegment _x0, long _x1, java.lang.foreign.MemorySegment _x2);
-        static MemorySegment allocate(bmap fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$28.const$1, fi, constants$26.const$1, scope);
+        read_buf() {
+            // Should not be called directly
         }
-        static bmap ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, long __x1, java.lang.foreign.MemorySegment __x2) -> {
-                try {
-                    return (int)constants$26.const$3.invokeExact(symbol, __x0, __x1, __x2);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, MemorySegment _x1, long _x2, long _x3, MemorySegment _x4);
         }
-    }
 
-    public static VarHandle bmap$VH() {
-        return constants$28.const$2;
-    }
-    /**
-     * Getter for field:
-     * {@snippet :
-     * int (*bmap)(char*,size_t,uint64_t*);
-     * }
-     */
-    public static MemorySegment bmap$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$28.const$2.get(seg);
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER,
+            fuse_h.C_LONG,
+            fuse_h.C_LONG_LONG,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(read_buf.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(read_buf.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1, long _x2, long _x3, MemorySegment _x4) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2, _x3, _x4);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
     }
+
+    private static final AddressLayout read_buf$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("read_buf"));
+
     /**
-     * Setter for field:
-     * {@snippet :
-     * int (*bmap)(char*,size_t,uint64_t*);
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*read_buf)(const char *, struct fuse_bufvec **, size_t, off_t, struct fuse_file_info *)
      * }
      */
-    public static void bmap$set(MemorySegment seg, MemorySegment x) {
-        constants$28.const$2.set(seg, x);
-    }
-    public static MemorySegment bmap$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$28.const$2.get(seg.asSlice(index*sizeof()));
-    }
-    public static void bmap$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$28.const$2.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static bmap bmap(MemorySegment segment, Arena scope) {
-        return bmap.ofAddress(bmap$get(segment), scope);
+    public static final AddressLayout read_buf$layout() {
+        return read_buf$LAYOUT;
     }
+
+    private static final long read_buf$OFFSET = 336;
+
     /**
-     * {@snippet :
- * int (*ioctl)(char*,int,void*,struct fuse_file_info*,unsigned int,void*);
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*read_buf)(const char *, struct fuse_bufvec **, size_t, off_t, struct fuse_file_info *)
      * }
      */
-    public interface ioctl {
-
-        int apply(java.lang.foreign.MemorySegment _x0, int _x1, java.lang.foreign.MemorySegment _x2, java.lang.foreign.MemorySegment _x3, int _x4, java.lang.foreign.MemorySegment _x5);
-        static MemorySegment allocate(ioctl fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$28.const$4, fi, constants$28.const$3, scope);
-        }
-        static ioctl ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, int __x1, java.lang.foreign.MemorySegment __x2, java.lang.foreign.MemorySegment __x3, int __x4, java.lang.foreign.MemorySegment __x5) -> {
-                try {
-                    return (int)constants$28.const$5.invokeExact(symbol, __x0, __x1, __x2, __x3, __x4, __x5);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
-        }
+    public static final long read_buf$offset() {
+        return read_buf$OFFSET;
     }
 
-    public static VarHandle ioctl$VH() {
-        return constants$29.const$0;
-    }
     /**
      * Getter for field:
-     * {@snippet :
-     * int (*ioctl)(char*,int,void*,struct fuse_file_info*,unsigned int,void*);
+     * {@snippet lang=c :
+     * int (*read_buf)(const char *, struct fuse_bufvec **, size_t, off_t, struct fuse_file_info *)
      * }
      */
-    public static MemorySegment ioctl$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$29.const$0.get(seg);
+    public static MemorySegment read_buf(MemorySegment struct) {
+        return struct.get(read_buf$LAYOUT, read_buf$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int (*ioctl)(char*,int,void*,struct fuse_file_info*,unsigned int,void*);
+     * {@snippet lang=c :
+     * int (*read_buf)(const char *, struct fuse_bufvec **, size_t, off_t, struct fuse_file_info *)
      * }
      */
-    public static void ioctl$set(MemorySegment seg, MemorySegment x) {
-        constants$29.const$0.set(seg, x);
-    }
-    public static MemorySegment ioctl$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$29.const$0.get(seg.asSlice(index*sizeof()));
-    }
-    public static void ioctl$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$29.const$0.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static ioctl ioctl(MemorySegment segment, Arena scope) {
-        return ioctl.ofAddress(ioctl$get(segment), scope);
+    public static void read_buf(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(read_buf$LAYOUT, read_buf$OFFSET, fieldValue);
     }
+
     /**
-     * {@snippet :
- * int (*poll)(char*,struct fuse_file_info*,struct fuse_pollhandle*,unsigned int*);
+     * {@snippet lang=c :
+     * int (*flock)(const char *, struct fuse_file_info *, int)
      * }
      */
-    public interface poll {
+    public static class flock {
 
-        int apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1, java.lang.foreign.MemorySegment _x2, java.lang.foreign.MemorySegment _x3);
-        static MemorySegment allocate(poll fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$29.const$1, fi, constants$4.const$0, scope);
+        flock() {
+            // Should not be called directly
         }
-        static poll ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1, java.lang.foreign.MemorySegment __x2, java.lang.foreign.MemorySegment __x3) -> {
-                try {
-                    return (int)constants$29.const$2.invokeExact(symbol, __x0, __x1, __x2, __x3);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, MemorySegment _x1, int _x2);
         }
-    }
 
-    public static VarHandle poll$VH() {
-        return constants$29.const$3;
-    }
-    /**
-     * Getter for field:
-     * {@snippet :
-     * int (*poll)(char*,struct fuse_file_info*,struct fuse_pollhandle*,unsigned int*);
-     * }
-     */
-    public static MemorySegment poll$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$29.const$3.get(seg);
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER,
+            fuse_h.C_INT
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(flock.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(flock.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1, int _x2) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
     }
+
+    private static final AddressLayout flock$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("flock"));
+
     /**
-     * Setter for field:
-     * {@snippet :
-     * int (*poll)(char*,struct fuse_file_info*,struct fuse_pollhandle*,unsigned int*);
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*flock)(const char *, struct fuse_file_info *, int)
      * }
      */
-    public static void poll$set(MemorySegment seg, MemorySegment x) {
-        constants$29.const$3.set(seg, x);
-    }
-    public static MemorySegment poll$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$29.const$3.get(seg.asSlice(index*sizeof()));
-    }
-    public static void poll$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$29.const$3.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static poll poll(MemorySegment segment, Arena scope) {
-        return poll.ofAddress(poll$get(segment), scope);
+    public static final AddressLayout flock$layout() {
+        return flock$LAYOUT;
     }
+
+    private static final long flock$OFFSET = 344;
+
     /**
-     * {@snippet :
- * int (*write_buf)(char*,struct fuse_bufvec*,off_t,struct fuse_file_info*);
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*flock)(const char *, struct fuse_file_info *, int)
      * }
      */
-    public interface write_buf {
-
-        int apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1, long _x2, java.lang.foreign.MemorySegment _x3);
-        static MemorySegment allocate(write_buf fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$29.const$5, fi, constants$29.const$4, scope);
-        }
-        static write_buf ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1, long __x2, java.lang.foreign.MemorySegment __x3) -> {
-                try {
-                    return (int)constants$30.const$0.invokeExact(symbol, __x0, __x1, __x2, __x3);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
-        }
+    public static final long flock$offset() {
+        return flock$OFFSET;
     }
 
-    public static VarHandle write_buf$VH() {
-        return constants$30.const$1;
-    }
     /**
      * Getter for field:
-     * {@snippet :
-     * int (*write_buf)(char*,struct fuse_bufvec*,off_t,struct fuse_file_info*);
+     * {@snippet lang=c :
+     * int (*flock)(const char *, struct fuse_file_info *, int)
      * }
      */
-    public static MemorySegment write_buf$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$30.const$1.get(seg);
+    public static MemorySegment flock(MemorySegment struct) {
+        return struct.get(flock$LAYOUT, flock$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int (*write_buf)(char*,struct fuse_bufvec*,off_t,struct fuse_file_info*);
+     * {@snippet lang=c :
+     * int (*flock)(const char *, struct fuse_file_info *, int)
      * }
      */
-    public static void write_buf$set(MemorySegment seg, MemorySegment x) {
-        constants$30.const$1.set(seg, x);
-    }
-    public static MemorySegment write_buf$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$30.const$1.get(seg.asSlice(index*sizeof()));
-    }
-    public static void write_buf$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$30.const$1.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static write_buf write_buf(MemorySegment segment, Arena scope) {
-        return write_buf.ofAddress(write_buf$get(segment), scope);
+    public static void flock(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(flock$LAYOUT, flock$OFFSET, fieldValue);
     }
+
     /**
-     * {@snippet :
- * int (*read_buf)(char*,struct fuse_bufvec**,size_t,off_t,struct fuse_file_info*);
+     * {@snippet lang=c :
+     * int (*fallocate)(const char *, int, off_t, off_t, struct fuse_file_info *)
      * }
      */
-    public interface read_buf {
+    public static class fallocate {
 
-        int apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1, long _x2, long _x3, java.lang.foreign.MemorySegment _x4);
-        static MemorySegment allocate(read_buf fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$30.const$2, fi, constants$17.const$3, scope);
+        fallocate() {
+            // Should not be called directly
         }
-        static read_buf ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1, long __x2, long __x3, java.lang.foreign.MemorySegment __x4) -> {
-                try {
-                    return (int)constants$17.const$5.invokeExact(symbol, __x0, __x1, __x2, __x3, __x4);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, int _x1, long _x2, long _x3, MemorySegment _x4);
         }
-    }
 
-    public static VarHandle read_buf$VH() {
-        return constants$30.const$3;
-    }
-    /**
-     * Getter for field:
-     * {@snippet :
-     * int (*read_buf)(char*,struct fuse_bufvec**,size_t,off_t,struct fuse_file_info*);
-     * }
-     */
-    public static MemorySegment read_buf$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$30.const$3.get(seg);
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_INT,
+            fuse_h.C_LONG_LONG,
+            fuse_h.C_LONG_LONG,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(fallocate.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(fallocate.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, int _x1, long _x2, long _x3, MemorySegment _x4) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2, _x3, _x4);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
     }
+
+    private static final AddressLayout fallocate$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("fallocate"));
+
     /**
-     * Setter for field:
-     * {@snippet :
-     * int (*read_buf)(char*,struct fuse_bufvec**,size_t,off_t,struct fuse_file_info*);
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*fallocate)(const char *, int, off_t, off_t, struct fuse_file_info *)
      * }
      */
-    public static void read_buf$set(MemorySegment seg, MemorySegment x) {
-        constants$30.const$3.set(seg, x);
-    }
-    public static MemorySegment read_buf$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$30.const$3.get(seg.asSlice(index*sizeof()));
-    }
-    public static void read_buf$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$30.const$3.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static read_buf read_buf(MemorySegment segment, Arena scope) {
-        return read_buf.ofAddress(read_buf$get(segment), scope);
+    public static final AddressLayout fallocate$layout() {
+        return fallocate$LAYOUT;
     }
+
+    private static final long fallocate$OFFSET = 352;
+
     /**
-     * {@snippet :
- * int (*flock)(char*,struct fuse_file_info*,int);
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*fallocate)(const char *, int, off_t, off_t, struct fuse_file_info *)
      * }
      */
-    public interface flock {
-
-        int apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1, int _x2);
-        static MemorySegment allocate(flock fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$30.const$5, fi, constants$30.const$4, scope);
-        }
-        static flock ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1, int __x2) -> {
-                try {
-                    return (int)constants$31.const$0.invokeExact(symbol, __x0, __x1, __x2);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
-        }
+    public static final long fallocate$offset() {
+        return fallocate$OFFSET;
     }
 
-    public static VarHandle flock$VH() {
-        return constants$31.const$1;
-    }
     /**
      * Getter for field:
-     * {@snippet :
-     * int (*flock)(char*,struct fuse_file_info*,int);
+     * {@snippet lang=c :
+     * int (*fallocate)(const char *, int, off_t, off_t, struct fuse_file_info *)
      * }
      */
-    public static MemorySegment flock$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$31.const$1.get(seg);
+    public static MemorySegment fallocate(MemorySegment struct) {
+        return struct.get(fallocate$LAYOUT, fallocate$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int (*flock)(char*,struct fuse_file_info*,int);
+     * {@snippet lang=c :
+     * int (*fallocate)(const char *, int, off_t, off_t, struct fuse_file_info *)
      * }
      */
-    public static void flock$set(MemorySegment seg, MemorySegment x) {
-        constants$31.const$1.set(seg, x);
+    public static void fallocate(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(fallocate$LAYOUT, fallocate$OFFSET, fieldValue);
     }
-    public static MemorySegment flock$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$31.const$1.get(seg.asSlice(index*sizeof()));
-    }
-    public static void flock$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$31.const$1.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static flock flock(MemorySegment segment, Arena scope) {
-        return flock.ofAddress(flock$get(segment), scope);
+
+    /**
+     * Obtains a slice of {@code arrayParam} which selects the array element at {@code index}.
+     * The returned segment has address {@code arrayParam.address() + index * layout().byteSize()}
+     */
+    public static MemorySegment asSlice(MemorySegment array, long index) {
+        return array.asSlice(layout().byteSize() * index);
     }
+
     /**
-     * {@snippet :
- * int (*fallocate)(char*,int,off_t,off_t,struct fuse_file_info*);
-     * }
+     * The size (in bytes) of this struct
      */
-    public interface fallocate {
+    public static long sizeof() { return layout().byteSize(); }
 
-        int apply(java.lang.foreign.MemorySegment _x0, int _x1, long _x2, long _x3, java.lang.foreign.MemorySegment _x4);
-        static MemorySegment allocate(fallocate fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$31.const$3, fi, constants$31.const$2, scope);
-        }
-        static fallocate ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, int __x1, long __x2, long __x3, java.lang.foreign.MemorySegment __x4) -> {
-                try {
-                    return (int)constants$31.const$4.invokeExact(symbol, __x0, __x1, __x2, __x3, __x4);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
-        }
+    /**
+     * Allocate a segment of size {@code layout().byteSize()} using {@code allocator}
+     */
+    public static MemorySegment allocate(SegmentAllocator allocator) {
+        return allocator.allocate(layout());
     }
 
-    public static VarHandle fallocate$VH() {
-        return constants$31.const$5;
-    }
     /**
-     * Getter for field:
-     * {@snippet :
-     * int (*fallocate)(char*,int,off_t,off_t,struct fuse_file_info*);
-     * }
+     * Allocate an array of size {@code elementCount} using {@code allocator}.
+     * The returned segment has size {@code elementCount * layout().byteSize()}.
      */
-    public static MemorySegment fallocate$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$31.const$5.get(seg);
+    public static MemorySegment allocateArray(long elementCount, SegmentAllocator allocator) {
+        return allocator.allocate(MemoryLayout.sequenceLayout(elementCount, layout()));
     }
+
     /**
-     * Setter for field:
-     * {@snippet :
-     * int (*fallocate)(char*,int,off_t,off_t,struct fuse_file_info*);
-     * }
+     * Reinterprets {@code addr} using target {@code arena} and {@code cleanupAction) (if any).
+     * The returned segment has size {@code layout().byteSize()}
      */
-    public static void fallocate$set(MemorySegment seg, MemorySegment x) {
-        constants$31.const$5.set(seg, x);
-    }
-    public static MemorySegment fallocate$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$31.const$5.get(seg.asSlice(index*sizeof()));
-    }
-    public static void fallocate$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$31.const$5.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static fallocate fallocate(MemorySegment segment, Arena scope) {
-        return fallocate.ofAddress(fallocate$get(segment), scope);
+    public static MemorySegment reinterpret(MemorySegment addr, Arena arena, Consumer<MemorySegment> cleanup) {
+        return reinterpret(addr, 1, arena, cleanup);
     }
-    public static long sizeof() { return $LAYOUT().byteSize(); }
-    public static MemorySegment allocate(SegmentAllocator allocator) { return allocator.allocate($LAYOUT()); }
-    public static MemorySegment allocateArray(long len, SegmentAllocator allocator) {
-        return allocator.allocate(MemoryLayout.sequenceLayout(len, $LAYOUT()));
+
+    /**
+     * Reinterprets {@code addr} using target {@code arena} and {@code cleanupAction) (if any).
+     * The returned segment has size {@code elementCount * layout().byteSize()}
+     */
+    public static MemorySegment reinterpret(MemorySegment addr, long elementCount, Arena arena, Consumer<MemorySegment> cleanup) {
+        return addr.reinterpret(layout().byteSize() * elementCount, arena, cleanup);
     }
-    public static MemorySegment ofAddress(MemorySegment addr, Arena scope) { return RuntimeHelper.asArray(addr, $LAYOUT(), 1, scope); }
 }
 
-
diff --git a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/stat.java b/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/stat.java
index 1a1e0380..b5b8fbdf 100644
--- a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/stat.java
+++ b/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/stat.java
@@ -2,13 +2,18 @@
 
 package org.cryptomator.jfuse.mac.extr.fuse;
 
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
+import java.lang.invoke.*;
 import java.lang.foreign.*;
+import java.nio.ByteOrder;
+import java.util.*;
+import java.util.function.*;
+import java.util.stream.*;
+
 import static java.lang.foreign.ValueLayout.*;
+import static java.lang.foreign.MemoryLayout.PathElement.*;
+
 /**
- * {@snippet :
+ * {@snippet lang=c :
  * struct stat {
  *     dev_t st_dev;
  *     mode_t st_mode;
@@ -28,386 +33,911 @@
  *     __uint32_t st_gen;
  *     __int32_t st_lspare;
  *     __int64_t st_qspare[2];
- * };
+ * }
  * }
  */
 public class stat {
 
-    public static MemoryLayout $LAYOUT() {
-        return constants$4.const$5;
+    stat() {
+        // Should not be called directly
     }
-    public static VarHandle st_dev$VH() {
-        return constants$5.const$0;
+
+    private static final GroupLayout $LAYOUT = MemoryLayout.structLayout(
+        fuse_h.C_INT.withName("st_dev"),
+        fuse_h.C_SHORT.withName("st_mode"),
+        fuse_h.C_SHORT.withName("st_nlink"),
+        fuse_h.C_LONG_LONG.withName("st_ino"),
+        fuse_h.C_INT.withName("st_uid"),
+        fuse_h.C_INT.withName("st_gid"),
+        fuse_h.C_INT.withName("st_rdev"),
+        MemoryLayout.paddingLayout(4),
+        timespec.layout().withName("st_atimespec"),
+        timespec.layout().withName("st_mtimespec"),
+        timespec.layout().withName("st_ctimespec"),
+        timespec.layout().withName("st_birthtimespec"),
+        fuse_h.C_LONG_LONG.withName("st_size"),
+        fuse_h.C_LONG_LONG.withName("st_blocks"),
+        fuse_h.C_INT.withName("st_blksize"),
+        fuse_h.C_INT.withName("st_flags"),
+        fuse_h.C_INT.withName("st_gen"),
+        fuse_h.C_INT.withName("st_lspare"),
+        MemoryLayout.sequenceLayout(2, fuse_h.C_LONG_LONG).withName("st_qspare")
+    ).withName("stat");
+
+    /**
+     * The layout of this struct
+     */
+    public static final GroupLayout layout() {
+        return $LAYOUT;
     }
+
+    private static final OfInt st_dev$LAYOUT = (OfInt)$LAYOUT.select(groupElement("st_dev"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * dev_t st_dev
+     * }
+     */
+    public static final OfInt st_dev$layout() {
+        return st_dev$LAYOUT;
+    }
+
+    private static final long st_dev$OFFSET = 0;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * dev_t st_dev
+     * }
+     */
+    public static final long st_dev$offset() {
+        return st_dev$OFFSET;
+    }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * dev_t st_dev;
+     * {@snippet lang=c :
+     * dev_t st_dev
      * }
      */
-    public static int st_dev$get(MemorySegment seg) {
-        return (int)constants$5.const$0.get(seg);
+    public static int st_dev(MemorySegment struct) {
+        return struct.get(st_dev$LAYOUT, st_dev$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * dev_t st_dev;
+     * {@snippet lang=c :
+     * dev_t st_dev
      * }
      */
-    public static void st_dev$set(MemorySegment seg, int x) {
-        constants$5.const$0.set(seg, x);
-    }
-    public static int st_dev$get(MemorySegment seg, long index) {
-        return (int)constants$5.const$0.get(seg.asSlice(index*sizeof()));
+    public static void st_dev(MemorySegment struct, int fieldValue) {
+        struct.set(st_dev$LAYOUT, st_dev$OFFSET, fieldValue);
     }
-    public static void st_dev$set(MemorySegment seg, long index, int x) {
-        constants$5.const$0.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfShort st_mode$LAYOUT = (OfShort)$LAYOUT.select(groupElement("st_mode"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * mode_t st_mode
+     * }
+     */
+    public static final OfShort st_mode$layout() {
+        return st_mode$LAYOUT;
     }
-    public static VarHandle st_mode$VH() {
-        return constants$5.const$1;
+
+    private static final long st_mode$OFFSET = 4;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * mode_t st_mode
+     * }
+     */
+    public static final long st_mode$offset() {
+        return st_mode$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * mode_t st_mode;
+     * {@snippet lang=c :
+     * mode_t st_mode
      * }
      */
-    public static short st_mode$get(MemorySegment seg) {
-        return (short)constants$5.const$1.get(seg);
+    public static short st_mode(MemorySegment struct) {
+        return struct.get(st_mode$LAYOUT, st_mode$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * mode_t st_mode;
+     * {@snippet lang=c :
+     * mode_t st_mode
      * }
      */
-    public static void st_mode$set(MemorySegment seg, short x) {
-        constants$5.const$1.set(seg, x);
+    public static void st_mode(MemorySegment struct, short fieldValue) {
+        struct.set(st_mode$LAYOUT, st_mode$OFFSET, fieldValue);
     }
-    public static short st_mode$get(MemorySegment seg, long index) {
-        return (short)constants$5.const$1.get(seg.asSlice(index*sizeof()));
-    }
-    public static void st_mode$set(MemorySegment seg, long index, short x) {
-        constants$5.const$1.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfShort st_nlink$LAYOUT = (OfShort)$LAYOUT.select(groupElement("st_nlink"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * nlink_t st_nlink
+     * }
+     */
+    public static final OfShort st_nlink$layout() {
+        return st_nlink$LAYOUT;
     }
-    public static VarHandle st_nlink$VH() {
-        return constants$5.const$2;
+
+    private static final long st_nlink$OFFSET = 6;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * nlink_t st_nlink
+     * }
+     */
+    public static final long st_nlink$offset() {
+        return st_nlink$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * nlink_t st_nlink;
+     * {@snippet lang=c :
+     * nlink_t st_nlink
      * }
      */
-    public static short st_nlink$get(MemorySegment seg) {
-        return (short)constants$5.const$2.get(seg);
+    public static short st_nlink(MemorySegment struct) {
+        return struct.get(st_nlink$LAYOUT, st_nlink$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * nlink_t st_nlink;
+     * {@snippet lang=c :
+     * nlink_t st_nlink
      * }
      */
-    public static void st_nlink$set(MemorySegment seg, short x) {
-        constants$5.const$2.set(seg, x);
+    public static void st_nlink(MemorySegment struct, short fieldValue) {
+        struct.set(st_nlink$LAYOUT, st_nlink$OFFSET, fieldValue);
     }
-    public static short st_nlink$get(MemorySegment seg, long index) {
-        return (short)constants$5.const$2.get(seg.asSlice(index*sizeof()));
-    }
-    public static void st_nlink$set(MemorySegment seg, long index, short x) {
-        constants$5.const$2.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfLong st_ino$LAYOUT = (OfLong)$LAYOUT.select(groupElement("st_ino"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * __darwin_ino64_t st_ino
+     * }
+     */
+    public static final OfLong st_ino$layout() {
+        return st_ino$LAYOUT;
     }
-    public static VarHandle st_ino$VH() {
-        return constants$5.const$3;
+
+    private static final long st_ino$OFFSET = 8;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * __darwin_ino64_t st_ino
+     * }
+     */
+    public static final long st_ino$offset() {
+        return st_ino$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * __darwin_ino64_t st_ino;
+     * {@snippet lang=c :
+     * __darwin_ino64_t st_ino
      * }
      */
-    public static long st_ino$get(MemorySegment seg) {
-        return (long)constants$5.const$3.get(seg);
+    public static long st_ino(MemorySegment struct) {
+        return struct.get(st_ino$LAYOUT, st_ino$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * __darwin_ino64_t st_ino;
+     * {@snippet lang=c :
+     * __darwin_ino64_t st_ino
      * }
      */
-    public static void st_ino$set(MemorySegment seg, long x) {
-        constants$5.const$3.set(seg, x);
-    }
-    public static long st_ino$get(MemorySegment seg, long index) {
-        return (long)constants$5.const$3.get(seg.asSlice(index*sizeof()));
+    public static void st_ino(MemorySegment struct, long fieldValue) {
+        struct.set(st_ino$LAYOUT, st_ino$OFFSET, fieldValue);
     }
-    public static void st_ino$set(MemorySegment seg, long index, long x) {
-        constants$5.const$3.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt st_uid$LAYOUT = (OfInt)$LAYOUT.select(groupElement("st_uid"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * uid_t st_uid
+     * }
+     */
+    public static final OfInt st_uid$layout() {
+        return st_uid$LAYOUT;
     }
-    public static VarHandle st_uid$VH() {
-        return constants$5.const$4;
+
+    private static final long st_uid$OFFSET = 16;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * uid_t st_uid
+     * }
+     */
+    public static final long st_uid$offset() {
+        return st_uid$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * uid_t st_uid;
+     * {@snippet lang=c :
+     * uid_t st_uid
      * }
      */
-    public static int st_uid$get(MemorySegment seg) {
-        return (int)constants$5.const$4.get(seg);
+    public static int st_uid(MemorySegment struct) {
+        return struct.get(st_uid$LAYOUT, st_uid$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * uid_t st_uid;
+     * {@snippet lang=c :
+     * uid_t st_uid
      * }
      */
-    public static void st_uid$set(MemorySegment seg, int x) {
-        constants$5.const$4.set(seg, x);
-    }
-    public static int st_uid$get(MemorySegment seg, long index) {
-        return (int)constants$5.const$4.get(seg.asSlice(index*sizeof()));
+    public static void st_uid(MemorySegment struct, int fieldValue) {
+        struct.set(st_uid$LAYOUT, st_uid$OFFSET, fieldValue);
     }
-    public static void st_uid$set(MemorySegment seg, long index, int x) {
-        constants$5.const$4.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt st_gid$LAYOUT = (OfInt)$LAYOUT.select(groupElement("st_gid"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * gid_t st_gid
+     * }
+     */
+    public static final OfInt st_gid$layout() {
+        return st_gid$LAYOUT;
     }
-    public static VarHandle st_gid$VH() {
-        return constants$5.const$5;
+
+    private static final long st_gid$OFFSET = 20;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * gid_t st_gid
+     * }
+     */
+    public static final long st_gid$offset() {
+        return st_gid$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * gid_t st_gid;
+     * {@snippet lang=c :
+     * gid_t st_gid
      * }
      */
-    public static int st_gid$get(MemorySegment seg) {
-        return (int)constants$5.const$5.get(seg);
+    public static int st_gid(MemorySegment struct) {
+        return struct.get(st_gid$LAYOUT, st_gid$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * gid_t st_gid;
+     * {@snippet lang=c :
+     * gid_t st_gid
      * }
      */
-    public static void st_gid$set(MemorySegment seg, int x) {
-        constants$5.const$5.set(seg, x);
-    }
-    public static int st_gid$get(MemorySegment seg, long index) {
-        return (int)constants$5.const$5.get(seg.asSlice(index*sizeof()));
+    public static void st_gid(MemorySegment struct, int fieldValue) {
+        struct.set(st_gid$LAYOUT, st_gid$OFFSET, fieldValue);
     }
-    public static void st_gid$set(MemorySegment seg, long index, int x) {
-        constants$5.const$5.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt st_rdev$LAYOUT = (OfInt)$LAYOUT.select(groupElement("st_rdev"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * dev_t st_rdev
+     * }
+     */
+    public static final OfInt st_rdev$layout() {
+        return st_rdev$LAYOUT;
     }
-    public static VarHandle st_rdev$VH() {
-        return constants$6.const$0;
+
+    private static final long st_rdev$OFFSET = 24;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * dev_t st_rdev
+     * }
+     */
+    public static final long st_rdev$offset() {
+        return st_rdev$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * dev_t st_rdev;
+     * {@snippet lang=c :
+     * dev_t st_rdev
      * }
      */
-    public static int st_rdev$get(MemorySegment seg) {
-        return (int)constants$6.const$0.get(seg);
+    public static int st_rdev(MemorySegment struct) {
+        return struct.get(st_rdev$LAYOUT, st_rdev$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * dev_t st_rdev;
+     * {@snippet lang=c :
+     * dev_t st_rdev
      * }
      */
-    public static void st_rdev$set(MemorySegment seg, int x) {
-        constants$6.const$0.set(seg, x);
-    }
-    public static int st_rdev$get(MemorySegment seg, long index) {
-        return (int)constants$6.const$0.get(seg.asSlice(index*sizeof()));
+    public static void st_rdev(MemorySegment struct, int fieldValue) {
+        struct.set(st_rdev$LAYOUT, st_rdev$OFFSET, fieldValue);
     }
-    public static void st_rdev$set(MemorySegment seg, long index, int x) {
-        constants$6.const$0.set(seg.asSlice(index*sizeof()), x);
+
+    private static final GroupLayout st_atimespec$LAYOUT = (GroupLayout)$LAYOUT.select(groupElement("st_atimespec"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * struct timespec st_atimespec
+     * }
+     */
+    public static final GroupLayout st_atimespec$layout() {
+        return st_atimespec$LAYOUT;
     }
-    public static MemorySegment st_atimespec$slice(MemorySegment seg) {
-        return seg.asSlice(32, 16);
+
+    private static final long st_atimespec$OFFSET = 32;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * struct timespec st_atimespec
+     * }
+     */
+    public static final long st_atimespec$offset() {
+        return st_atimespec$OFFSET;
     }
-    public static MemorySegment st_mtimespec$slice(MemorySegment seg) {
-        return seg.asSlice(48, 16);
+
+    /**
+     * Getter for field:
+     * {@snippet lang=c :
+     * struct timespec st_atimespec
+     * }
+     */
+    public static MemorySegment st_atimespec(MemorySegment struct) {
+        return struct.asSlice(st_atimespec$OFFSET, st_atimespec$LAYOUT.byteSize());
     }
-    public static MemorySegment st_ctimespec$slice(MemorySegment seg) {
-        return seg.asSlice(64, 16);
+
+    /**
+     * Setter for field:
+     * {@snippet lang=c :
+     * struct timespec st_atimespec
+     * }
+     */
+    public static void st_atimespec(MemorySegment struct, MemorySegment fieldValue) {
+        MemorySegment.copy(fieldValue, 0L, struct, st_atimespec$OFFSET, st_atimespec$LAYOUT.byteSize());
     }
-    public static MemorySegment st_birthtimespec$slice(MemorySegment seg) {
-        return seg.asSlice(80, 16);
+
+    private static final GroupLayout st_mtimespec$LAYOUT = (GroupLayout)$LAYOUT.select(groupElement("st_mtimespec"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * struct timespec st_mtimespec
+     * }
+     */
+    public static final GroupLayout st_mtimespec$layout() {
+        return st_mtimespec$LAYOUT;
     }
-    public static VarHandle st_size$VH() {
-        return constants$6.const$1;
+
+    private static final long st_mtimespec$OFFSET = 48;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * struct timespec st_mtimespec
+     * }
+     */
+    public static final long st_mtimespec$offset() {
+        return st_mtimespec$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * off_t st_size;
+     * {@snippet lang=c :
+     * struct timespec st_mtimespec
      * }
      */
-    public static long st_size$get(MemorySegment seg) {
-        return (long)constants$6.const$1.get(seg);
+    public static MemorySegment st_mtimespec(MemorySegment struct) {
+        return struct.asSlice(st_mtimespec$OFFSET, st_mtimespec$LAYOUT.byteSize());
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * off_t st_size;
+     * {@snippet lang=c :
+     * struct timespec st_mtimespec
      * }
      */
-    public static void st_size$set(MemorySegment seg, long x) {
-        constants$6.const$1.set(seg, x);
-    }
-    public static long st_size$get(MemorySegment seg, long index) {
-        return (long)constants$6.const$1.get(seg.asSlice(index*sizeof()));
+    public static void st_mtimespec(MemorySegment struct, MemorySegment fieldValue) {
+        MemorySegment.copy(fieldValue, 0L, struct, st_mtimespec$OFFSET, st_mtimespec$LAYOUT.byteSize());
     }
-    public static void st_size$set(MemorySegment seg, long index, long x) {
-        constants$6.const$1.set(seg.asSlice(index*sizeof()), x);
+
+    private static final GroupLayout st_ctimespec$LAYOUT = (GroupLayout)$LAYOUT.select(groupElement("st_ctimespec"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * struct timespec st_ctimespec
+     * }
+     */
+    public static final GroupLayout st_ctimespec$layout() {
+        return st_ctimespec$LAYOUT;
     }
-    public static VarHandle st_blocks$VH() {
-        return constants$6.const$2;
+
+    private static final long st_ctimespec$OFFSET = 64;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * struct timespec st_ctimespec
+     * }
+     */
+    public static final long st_ctimespec$offset() {
+        return st_ctimespec$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * blkcnt_t st_blocks;
+     * {@snippet lang=c :
+     * struct timespec st_ctimespec
      * }
      */
-    public static long st_blocks$get(MemorySegment seg) {
-        return (long)constants$6.const$2.get(seg);
+    public static MemorySegment st_ctimespec(MemorySegment struct) {
+        return struct.asSlice(st_ctimespec$OFFSET, st_ctimespec$LAYOUT.byteSize());
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * blkcnt_t st_blocks;
+     * {@snippet lang=c :
+     * struct timespec st_ctimespec
      * }
      */
-    public static void st_blocks$set(MemorySegment seg, long x) {
-        constants$6.const$2.set(seg, x);
+    public static void st_ctimespec(MemorySegment struct, MemorySegment fieldValue) {
+        MemorySegment.copy(fieldValue, 0L, struct, st_ctimespec$OFFSET, st_ctimespec$LAYOUT.byteSize());
     }
-    public static long st_blocks$get(MemorySegment seg, long index) {
-        return (long)constants$6.const$2.get(seg.asSlice(index*sizeof()));
+
+    private static final GroupLayout st_birthtimespec$LAYOUT = (GroupLayout)$LAYOUT.select(groupElement("st_birthtimespec"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * struct timespec st_birthtimespec
+     * }
+     */
+    public static final GroupLayout st_birthtimespec$layout() {
+        return st_birthtimespec$LAYOUT;
     }
-    public static void st_blocks$set(MemorySegment seg, long index, long x) {
-        constants$6.const$2.set(seg.asSlice(index*sizeof()), x);
+
+    private static final long st_birthtimespec$OFFSET = 80;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * struct timespec st_birthtimespec
+     * }
+     */
+    public static final long st_birthtimespec$offset() {
+        return st_birthtimespec$OFFSET;
     }
-    public static VarHandle st_blksize$VH() {
-        return constants$6.const$3;
+
+    /**
+     * Getter for field:
+     * {@snippet lang=c :
+     * struct timespec st_birthtimespec
+     * }
+     */
+    public static MemorySegment st_birthtimespec(MemorySegment struct) {
+        return struct.asSlice(st_birthtimespec$OFFSET, st_birthtimespec$LAYOUT.byteSize());
     }
+
+    /**
+     * Setter for field:
+     * {@snippet lang=c :
+     * struct timespec st_birthtimespec
+     * }
+     */
+    public static void st_birthtimespec(MemorySegment struct, MemorySegment fieldValue) {
+        MemorySegment.copy(fieldValue, 0L, struct, st_birthtimespec$OFFSET, st_birthtimespec$LAYOUT.byteSize());
+    }
+
+    private static final OfLong st_size$LAYOUT = (OfLong)$LAYOUT.select(groupElement("st_size"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * off_t st_size
+     * }
+     */
+    public static final OfLong st_size$layout() {
+        return st_size$LAYOUT;
+    }
+
+    private static final long st_size$OFFSET = 96;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * off_t st_size
+     * }
+     */
+    public static final long st_size$offset() {
+        return st_size$OFFSET;
+    }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * blksize_t st_blksize;
+     * {@snippet lang=c :
+     * off_t st_size
      * }
      */
-    public static int st_blksize$get(MemorySegment seg) {
-        return (int)constants$6.const$3.get(seg);
+    public static long st_size(MemorySegment struct) {
+        return struct.get(st_size$LAYOUT, st_size$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * blksize_t st_blksize;
+     * {@snippet lang=c :
+     * off_t st_size
      * }
      */
-    public static void st_blksize$set(MemorySegment seg, int x) {
-        constants$6.const$3.set(seg, x);
+    public static void st_size(MemorySegment struct, long fieldValue) {
+        struct.set(st_size$LAYOUT, st_size$OFFSET, fieldValue);
     }
-    public static int st_blksize$get(MemorySegment seg, long index) {
-        return (int)constants$6.const$3.get(seg.asSlice(index*sizeof()));
+
+    private static final OfLong st_blocks$LAYOUT = (OfLong)$LAYOUT.select(groupElement("st_blocks"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * blkcnt_t st_blocks
+     * }
+     */
+    public static final OfLong st_blocks$layout() {
+        return st_blocks$LAYOUT;
     }
-    public static void st_blksize$set(MemorySegment seg, long index, int x) {
-        constants$6.const$3.set(seg.asSlice(index*sizeof()), x);
+
+    private static final long st_blocks$OFFSET = 104;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * blkcnt_t st_blocks
+     * }
+     */
+    public static final long st_blocks$offset() {
+        return st_blocks$OFFSET;
     }
-    public static VarHandle st_flags$VH() {
-        return constants$6.const$4;
+
+    /**
+     * Getter for field:
+     * {@snippet lang=c :
+     * blkcnt_t st_blocks
+     * }
+     */
+    public static long st_blocks(MemorySegment struct) {
+        return struct.get(st_blocks$LAYOUT, st_blocks$OFFSET);
     }
+
+    /**
+     * Setter for field:
+     * {@snippet lang=c :
+     * blkcnt_t st_blocks
+     * }
+     */
+    public static void st_blocks(MemorySegment struct, long fieldValue) {
+        struct.set(st_blocks$LAYOUT, st_blocks$OFFSET, fieldValue);
+    }
+
+    private static final OfInt st_blksize$LAYOUT = (OfInt)$LAYOUT.select(groupElement("st_blksize"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * blksize_t st_blksize
+     * }
+     */
+    public static final OfInt st_blksize$layout() {
+        return st_blksize$LAYOUT;
+    }
+
+    private static final long st_blksize$OFFSET = 112;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * blksize_t st_blksize
+     * }
+     */
+    public static final long st_blksize$offset() {
+        return st_blksize$OFFSET;
+    }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * __uint32_t st_flags;
+     * {@snippet lang=c :
+     * blksize_t st_blksize
      * }
      */
-    public static int st_flags$get(MemorySegment seg) {
-        return (int)constants$6.const$4.get(seg);
+    public static int st_blksize(MemorySegment struct) {
+        return struct.get(st_blksize$LAYOUT, st_blksize$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * __uint32_t st_flags;
+     * {@snippet lang=c :
+     * blksize_t st_blksize
+     * }
+     */
+    public static void st_blksize(MemorySegment struct, int fieldValue) {
+        struct.set(st_blksize$LAYOUT, st_blksize$OFFSET, fieldValue);
+    }
+
+    private static final OfInt st_flags$LAYOUT = (OfInt)$LAYOUT.select(groupElement("st_flags"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * __uint32_t st_flags
      * }
      */
-    public static void st_flags$set(MemorySegment seg, int x) {
-        constants$6.const$4.set(seg, x);
+    public static final OfInt st_flags$layout() {
+        return st_flags$LAYOUT;
     }
-    public static int st_flags$get(MemorySegment seg, long index) {
-        return (int)constants$6.const$4.get(seg.asSlice(index*sizeof()));
+
+    private static final long st_flags$OFFSET = 116;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * __uint32_t st_flags
+     * }
+     */
+    public static final long st_flags$offset() {
+        return st_flags$OFFSET;
     }
-    public static void st_flags$set(MemorySegment seg, long index, int x) {
-        constants$6.const$4.set(seg.asSlice(index*sizeof()), x);
+
+    /**
+     * Getter for field:
+     * {@snippet lang=c :
+     * __uint32_t st_flags
+     * }
+     */
+    public static int st_flags(MemorySegment struct) {
+        return struct.get(st_flags$LAYOUT, st_flags$OFFSET);
     }
-    public static VarHandle st_gen$VH() {
-        return constants$6.const$5;
+
+    /**
+     * Setter for field:
+     * {@snippet lang=c :
+     * __uint32_t st_flags
+     * }
+     */
+    public static void st_flags(MemorySegment struct, int fieldValue) {
+        struct.set(st_flags$LAYOUT, st_flags$OFFSET, fieldValue);
     }
+
+    private static final OfInt st_gen$LAYOUT = (OfInt)$LAYOUT.select(groupElement("st_gen"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * __uint32_t st_gen
+     * }
+     */
+    public static final OfInt st_gen$layout() {
+        return st_gen$LAYOUT;
+    }
+
+    private static final long st_gen$OFFSET = 120;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * __uint32_t st_gen
+     * }
+     */
+    public static final long st_gen$offset() {
+        return st_gen$OFFSET;
+    }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * __uint32_t st_gen;
+     * {@snippet lang=c :
+     * __uint32_t st_gen
      * }
      */
-    public static int st_gen$get(MemorySegment seg) {
-        return (int)constants$6.const$5.get(seg);
+    public static int st_gen(MemorySegment struct) {
+        return struct.get(st_gen$LAYOUT, st_gen$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * __uint32_t st_gen;
+     * {@snippet lang=c :
+     * __uint32_t st_gen
+     * }
+     */
+    public static void st_gen(MemorySegment struct, int fieldValue) {
+        struct.set(st_gen$LAYOUT, st_gen$OFFSET, fieldValue);
+    }
+
+    private static final OfInt st_lspare$LAYOUT = (OfInt)$LAYOUT.select(groupElement("st_lspare"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * __int32_t st_lspare
+     * }
+     */
+    public static final OfInt st_lspare$layout() {
+        return st_lspare$LAYOUT;
+    }
+
+    private static final long st_lspare$OFFSET = 124;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * __int32_t st_lspare
+     * }
+     */
+    public static final long st_lspare$offset() {
+        return st_lspare$OFFSET;
+    }
+
+    /**
+     * Getter for field:
+     * {@snippet lang=c :
+     * __int32_t st_lspare
      * }
      */
-    public static void st_gen$set(MemorySegment seg, int x) {
-        constants$6.const$5.set(seg, x);
+    public static int st_lspare(MemorySegment struct) {
+        return struct.get(st_lspare$LAYOUT, st_lspare$OFFSET);
     }
-    public static int st_gen$get(MemorySegment seg, long index) {
-        return (int)constants$6.const$5.get(seg.asSlice(index*sizeof()));
+
+    /**
+     * Setter for field:
+     * {@snippet lang=c :
+     * __int32_t st_lspare
+     * }
+     */
+    public static void st_lspare(MemorySegment struct, int fieldValue) {
+        struct.set(st_lspare$LAYOUT, st_lspare$OFFSET, fieldValue);
     }
-    public static void st_gen$set(MemorySegment seg, long index, int x) {
-        constants$6.const$5.set(seg.asSlice(index*sizeof()), x);
+
+    private static final SequenceLayout st_qspare$LAYOUT = (SequenceLayout)$LAYOUT.select(groupElement("st_qspare"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * __int64_t st_qspare[2]
+     * }
+     */
+    public static final SequenceLayout st_qspare$layout() {
+        return st_qspare$LAYOUT;
     }
-    public static VarHandle st_lspare$VH() {
-        return constants$7.const$0;
+
+    private static final long st_qspare$OFFSET = 128;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * __int64_t st_qspare[2]
+     * }
+     */
+    public static final long st_qspare$offset() {
+        return st_qspare$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * __int32_t st_lspare;
+     * {@snippet lang=c :
+     * __int64_t st_qspare[2]
      * }
      */
-    public static int st_lspare$get(MemorySegment seg) {
-        return (int)constants$7.const$0.get(seg);
+    public static MemorySegment st_qspare(MemorySegment struct) {
+        return struct.asSlice(st_qspare$OFFSET, st_qspare$LAYOUT.byteSize());
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * __int32_t st_lspare;
+     * {@snippet lang=c :
+     * __int64_t st_qspare[2]
+     * }
+     */
+    public static void st_qspare(MemorySegment struct, MemorySegment fieldValue) {
+        MemorySegment.copy(fieldValue, 0L, struct, st_qspare$OFFSET, st_qspare$LAYOUT.byteSize());
+    }
+
+    private static long[] st_qspare$DIMS = { 2 };
+
+    /**
+     * Dimensions for array field:
+     * {@snippet lang=c :
+     * __int64_t st_qspare[2]
+     * }
+     */
+    public static long[] st_qspare$dimensions() {
+        return st_qspare$DIMS;
+    }
+    private static final VarHandle st_qspare$ELEM_HANDLE = st_qspare$LAYOUT.varHandle(sequenceElement());
+
+    /**
+     * Indexed getter for field:
+     * {@snippet lang=c :
+     * __int64_t st_qspare[2]
+     * }
+     */
+    public static long st_qspare(MemorySegment struct, long index0) {
+        return (long)st_qspare$ELEM_HANDLE.get(struct, 0L, index0);
+    }
+
+    /**
+     * Indexed setter for field:
+     * {@snippet lang=c :
+     * __int64_t st_qspare[2]
      * }
      */
-    public static void st_lspare$set(MemorySegment seg, int x) {
-        constants$7.const$0.set(seg, x);
+    public static void st_qspare(MemorySegment struct, long index0, long fieldValue) {
+        st_qspare$ELEM_HANDLE.set(struct, 0L, index0, fieldValue);
     }
-    public static int st_lspare$get(MemorySegment seg, long index) {
-        return (int)constants$7.const$0.get(seg.asSlice(index*sizeof()));
+
+    /**
+     * Obtains a slice of {@code arrayParam} which selects the array element at {@code index}.
+     * The returned segment has address {@code arrayParam.address() + index * layout().byteSize()}
+     */
+    public static MemorySegment asSlice(MemorySegment array, long index) {
+        return array.asSlice(layout().byteSize() * index);
+    }
+
+    /**
+     * The size (in bytes) of this struct
+     */
+    public static long sizeof() { return layout().byteSize(); }
+
+    /**
+     * Allocate a segment of size {@code layout().byteSize()} using {@code allocator}
+     */
+    public static MemorySegment allocate(SegmentAllocator allocator) {
+        return allocator.allocate(layout());
     }
-    public static void st_lspare$set(MemorySegment seg, long index, int x) {
-        constants$7.const$0.set(seg.asSlice(index*sizeof()), x);
+
+    /**
+     * Allocate an array of size {@code elementCount} using {@code allocator}.
+     * The returned segment has size {@code elementCount * layout().byteSize()}.
+     */
+    public static MemorySegment allocateArray(long elementCount, SegmentAllocator allocator) {
+        return allocator.allocate(MemoryLayout.sequenceLayout(elementCount, layout()));
     }
-    public static MemorySegment st_qspare$slice(MemorySegment seg) {
-        return seg.asSlice(128, 16);
+
+    /**
+     * Reinterprets {@code addr} using target {@code arena} and {@code cleanupAction) (if any).
+     * The returned segment has size {@code layout().byteSize()}
+     */
+    public static MemorySegment reinterpret(MemorySegment addr, Arena arena, Consumer<MemorySegment> cleanup) {
+        return reinterpret(addr, 1, arena, cleanup);
     }
-    public static long sizeof() { return $LAYOUT().byteSize(); }
-    public static MemorySegment allocate(SegmentAllocator allocator) { return allocator.allocate($LAYOUT()); }
-    public static MemorySegment allocateArray(long len, SegmentAllocator allocator) {
-        return allocator.allocate(MemoryLayout.sequenceLayout(len, $LAYOUT()));
+
+    /**
+     * Reinterprets {@code addr} using target {@code arena} and {@code cleanupAction) (if any).
+     * The returned segment has size {@code elementCount * layout().byteSize()}
+     */
+    public static MemorySegment reinterpret(MemorySegment addr, long elementCount, Arena arena, Consumer<MemorySegment> cleanup) {
+        return addr.reinterpret(layout().byteSize() * elementCount, arena, cleanup);
     }
-    public static MemorySegment ofAddress(MemorySegment addr, Arena scope) { return RuntimeHelper.asArray(addr, $LAYOUT(), 1, scope); }
 }
 
-
diff --git a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/statvfs.java b/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/statvfs.java
index ad181f48..17efeb85 100644
--- a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/statvfs.java
+++ b/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/statvfs.java
@@ -2,13 +2,18 @@
 
 package org.cryptomator.jfuse.mac.extr.fuse;
 
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
+import java.lang.invoke.*;
 import java.lang.foreign.*;
+import java.nio.ByteOrder;
+import java.util.*;
+import java.util.function.*;
+import java.util.stream.*;
+
 import static java.lang.foreign.ValueLayout.*;
+import static java.lang.foreign.MemoryLayout.PathElement.*;
+
 /**
- * {@snippet :
+ * {@snippet lang=c :
  * struct statvfs {
  *     unsigned long f_bsize;
  *     unsigned long f_frsize;
@@ -21,317 +26,562 @@
  *     unsigned long f_fsid;
  *     unsigned long f_flag;
  *     unsigned long f_namemax;
- * };
+ * }
  * }
  */
 public class statvfs {
 
-    public static MemoryLayout $LAYOUT() {
-        return constants$7.const$1;
+    statvfs() {
+        // Should not be called directly
+    }
+
+    private static final GroupLayout $LAYOUT = MemoryLayout.structLayout(
+        fuse_h.C_LONG.withName("f_bsize"),
+        fuse_h.C_LONG.withName("f_frsize"),
+        fuse_h.C_INT.withName("f_blocks"),
+        fuse_h.C_INT.withName("f_bfree"),
+        fuse_h.C_INT.withName("f_bavail"),
+        fuse_h.C_INT.withName("f_files"),
+        fuse_h.C_INT.withName("f_ffree"),
+        fuse_h.C_INT.withName("f_favail"),
+        fuse_h.C_LONG.withName("f_fsid"),
+        fuse_h.C_LONG.withName("f_flag"),
+        fuse_h.C_LONG.withName("f_namemax")
+    ).withName("statvfs");
+
+    /**
+     * The layout of this struct
+     */
+    public static final GroupLayout layout() {
+        return $LAYOUT;
+    }
+
+    private static final OfLong f_bsize$LAYOUT = (OfLong)$LAYOUT.select(groupElement("f_bsize"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * unsigned long f_bsize
+     * }
+     */
+    public static final OfLong f_bsize$layout() {
+        return f_bsize$LAYOUT;
     }
-    public static VarHandle f_bsize$VH() {
-        return constants$7.const$2;
+
+    private static final long f_bsize$OFFSET = 0;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * unsigned long f_bsize
+     * }
+     */
+    public static final long f_bsize$offset() {
+        return f_bsize$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned long f_bsize;
+     * {@snippet lang=c :
+     * unsigned long f_bsize
      * }
      */
-    public static long f_bsize$get(MemorySegment seg) {
-        return (long)constants$7.const$2.get(seg);
+    public static long f_bsize(MemorySegment struct) {
+        return struct.get(f_bsize$LAYOUT, f_bsize$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned long f_bsize;
+     * {@snippet lang=c :
+     * unsigned long f_bsize
      * }
      */
-    public static void f_bsize$set(MemorySegment seg, long x) {
-        constants$7.const$2.set(seg, x);
-    }
-    public static long f_bsize$get(MemorySegment seg, long index) {
-        return (long)constants$7.const$2.get(seg.asSlice(index*sizeof()));
+    public static void f_bsize(MemorySegment struct, long fieldValue) {
+        struct.set(f_bsize$LAYOUT, f_bsize$OFFSET, fieldValue);
     }
-    public static void f_bsize$set(MemorySegment seg, long index, long x) {
-        constants$7.const$2.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfLong f_frsize$LAYOUT = (OfLong)$LAYOUT.select(groupElement("f_frsize"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * unsigned long f_frsize
+     * }
+     */
+    public static final OfLong f_frsize$layout() {
+        return f_frsize$LAYOUT;
     }
-    public static VarHandle f_frsize$VH() {
-        return constants$7.const$3;
+
+    private static final long f_frsize$OFFSET = 8;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * unsigned long f_frsize
+     * }
+     */
+    public static final long f_frsize$offset() {
+        return f_frsize$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned long f_frsize;
+     * {@snippet lang=c :
+     * unsigned long f_frsize
      * }
      */
-    public static long f_frsize$get(MemorySegment seg) {
-        return (long)constants$7.const$3.get(seg);
+    public static long f_frsize(MemorySegment struct) {
+        return struct.get(f_frsize$LAYOUT, f_frsize$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned long f_frsize;
+     * {@snippet lang=c :
+     * unsigned long f_frsize
      * }
      */
-    public static void f_frsize$set(MemorySegment seg, long x) {
-        constants$7.const$3.set(seg, x);
+    public static void f_frsize(MemorySegment struct, long fieldValue) {
+        struct.set(f_frsize$LAYOUT, f_frsize$OFFSET, fieldValue);
     }
-    public static long f_frsize$get(MemorySegment seg, long index) {
-        return (long)constants$7.const$3.get(seg.asSlice(index*sizeof()));
-    }
-    public static void f_frsize$set(MemorySegment seg, long index, long x) {
-        constants$7.const$3.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt f_blocks$LAYOUT = (OfInt)$LAYOUT.select(groupElement("f_blocks"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * fsblkcnt_t f_blocks
+     * }
+     */
+    public static final OfInt f_blocks$layout() {
+        return f_blocks$LAYOUT;
     }
-    public static VarHandle f_blocks$VH() {
-        return constants$7.const$4;
+
+    private static final long f_blocks$OFFSET = 16;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * fsblkcnt_t f_blocks
+     * }
+     */
+    public static final long f_blocks$offset() {
+        return f_blocks$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * fsblkcnt_t f_blocks;
+     * {@snippet lang=c :
+     * fsblkcnt_t f_blocks
      * }
      */
-    public static int f_blocks$get(MemorySegment seg) {
-        return (int)constants$7.const$4.get(seg);
+    public static int f_blocks(MemorySegment struct) {
+        return struct.get(f_blocks$LAYOUT, f_blocks$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * fsblkcnt_t f_blocks;
+     * {@snippet lang=c :
+     * fsblkcnt_t f_blocks
      * }
      */
-    public static void f_blocks$set(MemorySegment seg, int x) {
-        constants$7.const$4.set(seg, x);
-    }
-    public static int f_blocks$get(MemorySegment seg, long index) {
-        return (int)constants$7.const$4.get(seg.asSlice(index*sizeof()));
+    public static void f_blocks(MemorySegment struct, int fieldValue) {
+        struct.set(f_blocks$LAYOUT, f_blocks$OFFSET, fieldValue);
     }
-    public static void f_blocks$set(MemorySegment seg, long index, int x) {
-        constants$7.const$4.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt f_bfree$LAYOUT = (OfInt)$LAYOUT.select(groupElement("f_bfree"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * fsblkcnt_t f_bfree
+     * }
+     */
+    public static final OfInt f_bfree$layout() {
+        return f_bfree$LAYOUT;
     }
-    public static VarHandle f_bfree$VH() {
-        return constants$7.const$5;
+
+    private static final long f_bfree$OFFSET = 20;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * fsblkcnt_t f_bfree
+     * }
+     */
+    public static final long f_bfree$offset() {
+        return f_bfree$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * fsblkcnt_t f_bfree;
+     * {@snippet lang=c :
+     * fsblkcnt_t f_bfree
      * }
      */
-    public static int f_bfree$get(MemorySegment seg) {
-        return (int)constants$7.const$5.get(seg);
+    public static int f_bfree(MemorySegment struct) {
+        return struct.get(f_bfree$LAYOUT, f_bfree$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * fsblkcnt_t f_bfree;
+     * {@snippet lang=c :
+     * fsblkcnt_t f_bfree
      * }
      */
-    public static void f_bfree$set(MemorySegment seg, int x) {
-        constants$7.const$5.set(seg, x);
-    }
-    public static int f_bfree$get(MemorySegment seg, long index) {
-        return (int)constants$7.const$5.get(seg.asSlice(index*sizeof()));
+    public static void f_bfree(MemorySegment struct, int fieldValue) {
+        struct.set(f_bfree$LAYOUT, f_bfree$OFFSET, fieldValue);
     }
-    public static void f_bfree$set(MemorySegment seg, long index, int x) {
-        constants$7.const$5.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt f_bavail$LAYOUT = (OfInt)$LAYOUT.select(groupElement("f_bavail"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * fsblkcnt_t f_bavail
+     * }
+     */
+    public static final OfInt f_bavail$layout() {
+        return f_bavail$LAYOUT;
     }
-    public static VarHandle f_bavail$VH() {
-        return constants$8.const$0;
+
+    private static final long f_bavail$OFFSET = 24;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * fsblkcnt_t f_bavail
+     * }
+     */
+    public static final long f_bavail$offset() {
+        return f_bavail$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * fsblkcnt_t f_bavail;
+     * {@snippet lang=c :
+     * fsblkcnt_t f_bavail
      * }
      */
-    public static int f_bavail$get(MemorySegment seg) {
-        return (int)constants$8.const$0.get(seg);
+    public static int f_bavail(MemorySegment struct) {
+        return struct.get(f_bavail$LAYOUT, f_bavail$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * fsblkcnt_t f_bavail;
+     * {@snippet lang=c :
+     * fsblkcnt_t f_bavail
      * }
      */
-    public static void f_bavail$set(MemorySegment seg, int x) {
-        constants$8.const$0.set(seg, x);
+    public static void f_bavail(MemorySegment struct, int fieldValue) {
+        struct.set(f_bavail$LAYOUT, f_bavail$OFFSET, fieldValue);
     }
-    public static int f_bavail$get(MemorySegment seg, long index) {
-        return (int)constants$8.const$0.get(seg.asSlice(index*sizeof()));
-    }
-    public static void f_bavail$set(MemorySegment seg, long index, int x) {
-        constants$8.const$0.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt f_files$LAYOUT = (OfInt)$LAYOUT.select(groupElement("f_files"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * fsfilcnt_t f_files
+     * }
+     */
+    public static final OfInt f_files$layout() {
+        return f_files$LAYOUT;
     }
-    public static VarHandle f_files$VH() {
-        return constants$8.const$1;
+
+    private static final long f_files$OFFSET = 28;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * fsfilcnt_t f_files
+     * }
+     */
+    public static final long f_files$offset() {
+        return f_files$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * fsfilcnt_t f_files;
+     * {@snippet lang=c :
+     * fsfilcnt_t f_files
      * }
      */
-    public static int f_files$get(MemorySegment seg) {
-        return (int)constants$8.const$1.get(seg);
+    public static int f_files(MemorySegment struct) {
+        return struct.get(f_files$LAYOUT, f_files$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * fsfilcnt_t f_files;
+     * {@snippet lang=c :
+     * fsfilcnt_t f_files
      * }
      */
-    public static void f_files$set(MemorySegment seg, int x) {
-        constants$8.const$1.set(seg, x);
-    }
-    public static int f_files$get(MemorySegment seg, long index) {
-        return (int)constants$8.const$1.get(seg.asSlice(index*sizeof()));
+    public static void f_files(MemorySegment struct, int fieldValue) {
+        struct.set(f_files$LAYOUT, f_files$OFFSET, fieldValue);
     }
-    public static void f_files$set(MemorySegment seg, long index, int x) {
-        constants$8.const$1.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt f_ffree$LAYOUT = (OfInt)$LAYOUT.select(groupElement("f_ffree"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * fsfilcnt_t f_ffree
+     * }
+     */
+    public static final OfInt f_ffree$layout() {
+        return f_ffree$LAYOUT;
     }
-    public static VarHandle f_ffree$VH() {
-        return constants$8.const$2;
+
+    private static final long f_ffree$OFFSET = 32;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * fsfilcnt_t f_ffree
+     * }
+     */
+    public static final long f_ffree$offset() {
+        return f_ffree$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * fsfilcnt_t f_ffree;
+     * {@snippet lang=c :
+     * fsfilcnt_t f_ffree
      * }
      */
-    public static int f_ffree$get(MemorySegment seg) {
-        return (int)constants$8.const$2.get(seg);
+    public static int f_ffree(MemorySegment struct) {
+        return struct.get(f_ffree$LAYOUT, f_ffree$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * fsfilcnt_t f_ffree;
+     * {@snippet lang=c :
+     * fsfilcnt_t f_ffree
      * }
      */
-    public static void f_ffree$set(MemorySegment seg, int x) {
-        constants$8.const$2.set(seg, x);
+    public static void f_ffree(MemorySegment struct, int fieldValue) {
+        struct.set(f_ffree$LAYOUT, f_ffree$OFFSET, fieldValue);
     }
-    public static int f_ffree$get(MemorySegment seg, long index) {
-        return (int)constants$8.const$2.get(seg.asSlice(index*sizeof()));
-    }
-    public static void f_ffree$set(MemorySegment seg, long index, int x) {
-        constants$8.const$2.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt f_favail$LAYOUT = (OfInt)$LAYOUT.select(groupElement("f_favail"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * fsfilcnt_t f_favail
+     * }
+     */
+    public static final OfInt f_favail$layout() {
+        return f_favail$LAYOUT;
     }
-    public static VarHandle f_favail$VH() {
-        return constants$8.const$3;
+
+    private static final long f_favail$OFFSET = 36;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * fsfilcnt_t f_favail
+     * }
+     */
+    public static final long f_favail$offset() {
+        return f_favail$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * fsfilcnt_t f_favail;
+     * {@snippet lang=c :
+     * fsfilcnt_t f_favail
      * }
      */
-    public static int f_favail$get(MemorySegment seg) {
-        return (int)constants$8.const$3.get(seg);
+    public static int f_favail(MemorySegment struct) {
+        return struct.get(f_favail$LAYOUT, f_favail$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * fsfilcnt_t f_favail;
+     * {@snippet lang=c :
+     * fsfilcnt_t f_favail
      * }
      */
-    public static void f_favail$set(MemorySegment seg, int x) {
-        constants$8.const$3.set(seg, x);
-    }
-    public static int f_favail$get(MemorySegment seg, long index) {
-        return (int)constants$8.const$3.get(seg.asSlice(index*sizeof()));
+    public static void f_favail(MemorySegment struct, int fieldValue) {
+        struct.set(f_favail$LAYOUT, f_favail$OFFSET, fieldValue);
     }
-    public static void f_favail$set(MemorySegment seg, long index, int x) {
-        constants$8.const$3.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfLong f_fsid$LAYOUT = (OfLong)$LAYOUT.select(groupElement("f_fsid"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * unsigned long f_fsid
+     * }
+     */
+    public static final OfLong f_fsid$layout() {
+        return f_fsid$LAYOUT;
     }
-    public static VarHandle f_fsid$VH() {
-        return constants$8.const$4;
+
+    private static final long f_fsid$OFFSET = 40;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * unsigned long f_fsid
+     * }
+     */
+    public static final long f_fsid$offset() {
+        return f_fsid$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned long f_fsid;
+     * {@snippet lang=c :
+     * unsigned long f_fsid
      * }
      */
-    public static long f_fsid$get(MemorySegment seg) {
-        return (long)constants$8.const$4.get(seg);
+    public static long f_fsid(MemorySegment struct) {
+        return struct.get(f_fsid$LAYOUT, f_fsid$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned long f_fsid;
+     * {@snippet lang=c :
+     * unsigned long f_fsid
      * }
      */
-    public static void f_fsid$set(MemorySegment seg, long x) {
-        constants$8.const$4.set(seg, x);
-    }
-    public static long f_fsid$get(MemorySegment seg, long index) {
-        return (long)constants$8.const$4.get(seg.asSlice(index*sizeof()));
+    public static void f_fsid(MemorySegment struct, long fieldValue) {
+        struct.set(f_fsid$LAYOUT, f_fsid$OFFSET, fieldValue);
     }
-    public static void f_fsid$set(MemorySegment seg, long index, long x) {
-        constants$8.const$4.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfLong f_flag$LAYOUT = (OfLong)$LAYOUT.select(groupElement("f_flag"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * unsigned long f_flag
+     * }
+     */
+    public static final OfLong f_flag$layout() {
+        return f_flag$LAYOUT;
     }
-    public static VarHandle f_flag$VH() {
-        return constants$8.const$5;
+
+    private static final long f_flag$OFFSET = 48;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * unsigned long f_flag
+     * }
+     */
+    public static final long f_flag$offset() {
+        return f_flag$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned long f_flag;
+     * {@snippet lang=c :
+     * unsigned long f_flag
      * }
      */
-    public static long f_flag$get(MemorySegment seg) {
-        return (long)constants$8.const$5.get(seg);
+    public static long f_flag(MemorySegment struct) {
+        return struct.get(f_flag$LAYOUT, f_flag$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned long f_flag;
+     * {@snippet lang=c :
+     * unsigned long f_flag
      * }
      */
-    public static void f_flag$set(MemorySegment seg, long x) {
-        constants$8.const$5.set(seg, x);
+    public static void f_flag(MemorySegment struct, long fieldValue) {
+        struct.set(f_flag$LAYOUT, f_flag$OFFSET, fieldValue);
     }
-    public static long f_flag$get(MemorySegment seg, long index) {
-        return (long)constants$8.const$5.get(seg.asSlice(index*sizeof()));
-    }
-    public static void f_flag$set(MemorySegment seg, long index, long x) {
-        constants$8.const$5.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfLong f_namemax$LAYOUT = (OfLong)$LAYOUT.select(groupElement("f_namemax"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * unsigned long f_namemax
+     * }
+     */
+    public static final OfLong f_namemax$layout() {
+        return f_namemax$LAYOUT;
     }
-    public static VarHandle f_namemax$VH() {
-        return constants$9.const$0;
+
+    private static final long f_namemax$OFFSET = 56;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * unsigned long f_namemax
+     * }
+     */
+    public static final long f_namemax$offset() {
+        return f_namemax$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned long f_namemax;
+     * {@snippet lang=c :
+     * unsigned long f_namemax
      * }
      */
-    public static long f_namemax$get(MemorySegment seg) {
-        return (long)constants$9.const$0.get(seg);
+    public static long f_namemax(MemorySegment struct) {
+        return struct.get(f_namemax$LAYOUT, f_namemax$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned long f_namemax;
+     * {@snippet lang=c :
+     * unsigned long f_namemax
      * }
      */
-    public static void f_namemax$set(MemorySegment seg, long x) {
-        constants$9.const$0.set(seg, x);
+    public static void f_namemax(MemorySegment struct, long fieldValue) {
+        struct.set(f_namemax$LAYOUT, f_namemax$OFFSET, fieldValue);
     }
-    public static long f_namemax$get(MemorySegment seg, long index) {
-        return (long)constants$9.const$0.get(seg.asSlice(index*sizeof()));
+
+    /**
+     * Obtains a slice of {@code arrayParam} which selects the array element at {@code index}.
+     * The returned segment has address {@code arrayParam.address() + index * layout().byteSize()}
+     */
+    public static MemorySegment asSlice(MemorySegment array, long index) {
+        return array.asSlice(layout().byteSize() * index);
     }
-    public static void f_namemax$set(MemorySegment seg, long index, long x) {
-        constants$9.const$0.set(seg.asSlice(index*sizeof()), x);
+
+    /**
+     * The size (in bytes) of this struct
+     */
+    public static long sizeof() { return layout().byteSize(); }
+
+    /**
+     * Allocate a segment of size {@code layout().byteSize()} using {@code allocator}
+     */
+    public static MemorySegment allocate(SegmentAllocator allocator) {
+        return allocator.allocate(layout());
     }
-    public static long sizeof() { return $LAYOUT().byteSize(); }
-    public static MemorySegment allocate(SegmentAllocator allocator) { return allocator.allocate($LAYOUT()); }
-    public static MemorySegment allocateArray(long len, SegmentAllocator allocator) {
-        return allocator.allocate(MemoryLayout.sequenceLayout(len, $LAYOUT()));
+
+    /**
+     * Allocate an array of size {@code elementCount} using {@code allocator}.
+     * The returned segment has size {@code elementCount * layout().byteSize()}.
+     */
+    public static MemorySegment allocateArray(long elementCount, SegmentAllocator allocator) {
+        return allocator.allocate(MemoryLayout.sequenceLayout(elementCount, layout()));
+    }
+
+    /**
+     * Reinterprets {@code addr} using target {@code arena} and {@code cleanupAction) (if any).
+     * The returned segment has size {@code layout().byteSize()}
+     */
+    public static MemorySegment reinterpret(MemorySegment addr, Arena arena, Consumer<MemorySegment> cleanup) {
+        return reinterpret(addr, 1, arena, cleanup);
     }
-    public static MemorySegment ofAddress(MemorySegment addr, Arena scope) { return RuntimeHelper.asArray(addr, $LAYOUT(), 1, scope); }
-}
 
+    /**
+     * Reinterprets {@code addr} using target {@code arena} and {@code cleanupAction) (if any).
+     * The returned segment has size {@code elementCount * layout().byteSize()}
+     */
+    public static MemorySegment reinterpret(MemorySegment addr, long elementCount, Arena arena, Consumer<MemorySegment> cleanup) {
+        return addr.reinterpret(layout().byteSize() * elementCount, arena, cleanup);
+    }
+}
 
diff --git a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/timespec.java b/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/timespec.java
index d52b58b4..bebe9dda 100644
--- a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/timespec.java
+++ b/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse/timespec.java
@@ -2,84 +2,172 @@
 
 package org.cryptomator.jfuse.mac.extr.fuse;
 
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
+import java.lang.invoke.*;
 import java.lang.foreign.*;
+import java.nio.ByteOrder;
+import java.util.*;
+import java.util.function.*;
+import java.util.stream.*;
+
 import static java.lang.foreign.ValueLayout.*;
+import static java.lang.foreign.MemoryLayout.PathElement.*;
+
 /**
- * {@snippet :
+ * {@snippet lang=c :
  * struct timespec {
  *     __darwin_time_t tv_sec;
  *     long tv_nsec;
- * };
+ * }
  * }
  */
 public class timespec {
 
-    public static MemoryLayout $LAYOUT() {
-        return constants$4.const$2;
+    timespec() {
+        // Should not be called directly
     }
-    public static VarHandle tv_sec$VH() {
-        return constants$4.const$3;
+
+    private static final GroupLayout $LAYOUT = MemoryLayout.structLayout(
+        fuse_h.C_LONG.withName("tv_sec"),
+        fuse_h.C_LONG.withName("tv_nsec")
+    ).withName("timespec");
+
+    /**
+     * The layout of this struct
+     */
+    public static final GroupLayout layout() {
+        return $LAYOUT;
     }
+
+    private static final OfLong tv_sec$LAYOUT = (OfLong)$LAYOUT.select(groupElement("tv_sec"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * __darwin_time_t tv_sec
+     * }
+     */
+    public static final OfLong tv_sec$layout() {
+        return tv_sec$LAYOUT;
+    }
+
+    private static final long tv_sec$OFFSET = 0;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * __darwin_time_t tv_sec
+     * }
+     */
+    public static final long tv_sec$offset() {
+        return tv_sec$OFFSET;
+    }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * __darwin_time_t tv_sec;
+     * {@snippet lang=c :
+     * __darwin_time_t tv_sec
      * }
      */
-    public static long tv_sec$get(MemorySegment seg) {
-        return (long)constants$4.const$3.get(seg);
+    public static long tv_sec(MemorySegment struct) {
+        return struct.get(tv_sec$LAYOUT, tv_sec$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * __darwin_time_t tv_sec;
+     * {@snippet lang=c :
+     * __darwin_time_t tv_sec
      * }
      */
-    public static void tv_sec$set(MemorySegment seg, long x) {
-        constants$4.const$3.set(seg, x);
-    }
-    public static long tv_sec$get(MemorySegment seg, long index) {
-        return (long)constants$4.const$3.get(seg.asSlice(index*sizeof()));
+    public static void tv_sec(MemorySegment struct, long fieldValue) {
+        struct.set(tv_sec$LAYOUT, tv_sec$OFFSET, fieldValue);
     }
-    public static void tv_sec$set(MemorySegment seg, long index, long x) {
-        constants$4.const$3.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfLong tv_nsec$LAYOUT = (OfLong)$LAYOUT.select(groupElement("tv_nsec"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * long tv_nsec
+     * }
+     */
+    public static final OfLong tv_nsec$layout() {
+        return tv_nsec$LAYOUT;
     }
-    public static VarHandle tv_nsec$VH() {
-        return constants$4.const$4;
+
+    private static final long tv_nsec$OFFSET = 8;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * long tv_nsec
+     * }
+     */
+    public static final long tv_nsec$offset() {
+        return tv_nsec$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * long tv_nsec;
+     * {@snippet lang=c :
+     * long tv_nsec
      * }
      */
-    public static long tv_nsec$get(MemorySegment seg) {
-        return (long)constants$4.const$4.get(seg);
+    public static long tv_nsec(MemorySegment struct) {
+        return struct.get(tv_nsec$LAYOUT, tv_nsec$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * long tv_nsec;
+     * {@snippet lang=c :
+     * long tv_nsec
      * }
      */
-    public static void tv_nsec$set(MemorySegment seg, long x) {
-        constants$4.const$4.set(seg, x);
+    public static void tv_nsec(MemorySegment struct, long fieldValue) {
+        struct.set(tv_nsec$LAYOUT, tv_nsec$OFFSET, fieldValue);
+    }
+
+    /**
+     * Obtains a slice of {@code arrayParam} which selects the array element at {@code index}.
+     * The returned segment has address {@code arrayParam.address() + index * layout().byteSize()}
+     */
+    public static MemorySegment asSlice(MemorySegment array, long index) {
+        return array.asSlice(layout().byteSize() * index);
+    }
+
+    /**
+     * The size (in bytes) of this struct
+     */
+    public static long sizeof() { return layout().byteSize(); }
+
+    /**
+     * Allocate a segment of size {@code layout().byteSize()} using {@code allocator}
+     */
+    public static MemorySegment allocate(SegmentAllocator allocator) {
+        return allocator.allocate(layout());
     }
-    public static long tv_nsec$get(MemorySegment seg, long index) {
-        return (long)constants$4.const$4.get(seg.asSlice(index*sizeof()));
+
+    /**
+     * Allocate an array of size {@code elementCount} using {@code allocator}.
+     * The returned segment has size {@code elementCount * layout().byteSize()}.
+     */
+    public static MemorySegment allocateArray(long elementCount, SegmentAllocator allocator) {
+        return allocator.allocate(MemoryLayout.sequenceLayout(elementCount, layout()));
     }
-    public static void tv_nsec$set(MemorySegment seg, long index, long x) {
-        constants$4.const$4.set(seg.asSlice(index*sizeof()), x);
+
+    /**
+     * Reinterprets {@code addr} using target {@code arena} and {@code cleanupAction) (if any).
+     * The returned segment has size {@code layout().byteSize()}
+     */
+    public static MemorySegment reinterpret(MemorySegment addr, Arena arena, Consumer<MemorySegment> cleanup) {
+        return reinterpret(addr, 1, arena, cleanup);
     }
-    public static long sizeof() { return $LAYOUT().byteSize(); }
-    public static MemorySegment allocate(SegmentAllocator allocator) { return allocator.allocate($LAYOUT()); }
-    public static MemorySegment allocateArray(long len, SegmentAllocator allocator) {
-        return allocator.allocate(MemoryLayout.sequenceLayout(len, $LAYOUT()));
+
+    /**
+     * Reinterprets {@code addr} using target {@code arena} and {@code cleanupAction) (if any).
+     * The returned segment has size {@code elementCount * layout().byteSize()}
+     */
+    public static MemorySegment reinterpret(MemorySegment addr, long elementCount, Arena arena, Consumer<MemorySegment> cleanup) {
+        return addr.reinterpret(layout().byteSize() * elementCount, arena, cleanup);
     }
-    public static MemorySegment ofAddress(MemorySegment addr, Arena scope) { return RuntimeHelper.asArray(addr, $LAYOUT(), 1, scope); }
 }
 
-
diff --git a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/stat/RuntimeHelper.java b/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/stat/RuntimeHelper.java
deleted file mode 100644
index bfaad500..00000000
--- a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/stat/RuntimeHelper.java
+++ /dev/null
@@ -1,245 +0,0 @@
-package org.cryptomator.jfuse.mac.extr.stat;
-// Generated by jextract
-
-import java.lang.foreign.Linker;
-import java.lang.foreign.FunctionDescriptor;
-import java.lang.foreign.GroupLayout;
-import java.lang.foreign.SymbolLookup;
-import java.lang.foreign.MemoryLayout;
-import java.lang.foreign.MemorySegment;
-import java.lang.foreign.Arena;
-import java.lang.foreign.SegmentAllocator;
-import java.lang.foreign.ValueLayout;
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.MethodHandles;
-import java.lang.invoke.MethodType;
-import java.io.File;
-import java.nio.file.Path;
-import java.nio.charset.StandardCharsets;
-import java.util.Arrays;
-import java.util.Optional;
-import java.util.stream.Stream;
-
-import java.lang.foreign.AddressLayout;
-import java.lang.foreign.MemoryLayout;
-
-import static java.lang.foreign.Linker.*;
-import static java.lang.foreign.ValueLayout.*;
-
-final class RuntimeHelper {
-
-    private static final Linker LINKER = Linker.nativeLinker();
-    private static final ClassLoader LOADER = RuntimeHelper.class.getClassLoader();
-    private static final MethodHandles.Lookup MH_LOOKUP = MethodHandles.lookup();
-    private static final SymbolLookup SYMBOL_LOOKUP;
-    private static final SegmentAllocator THROWING_ALLOCATOR = (x, y) -> { throw new AssertionError("should not reach here"); };
-    static final AddressLayout POINTER = ValueLayout.ADDRESS.withTargetLayout(MemoryLayout.sequenceLayout(JAVA_BYTE));
-
-    final static SegmentAllocator CONSTANT_ALLOCATOR =
-            (size, align) -> Arena.ofAuto().allocate(size, align);
-
-    static {
-        
-        SymbolLookup loaderLookup = SymbolLookup.loaderLookup();
-        SYMBOL_LOOKUP = name -> loaderLookup.find(name).or(() -> LINKER.defaultLookup().find(name));
-    }
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private RuntimeHelper() {}
-
-    static <T> T requireNonNull(T obj, String symbolName) {
-        if (obj == null) {
-            throw new UnsatisfiedLinkError("unresolved symbol: " + symbolName);
-        }
-        return obj;
-    }
-
-    static MemorySegment lookupGlobalVariable(String name, MemoryLayout layout) {
-        return SYMBOL_LOOKUP.find(name)
-                .map(s -> s.reinterpret(layout.byteSize()))
-                .orElse(null);
-    }
-
-    static MethodHandle downcallHandle(String name, FunctionDescriptor fdesc) {
-        return SYMBOL_LOOKUP.find(name).
-                map(addr -> LINKER.downcallHandle(addr, fdesc)).
-                orElse(null);
-    }
-
-    static MethodHandle downcallHandle(FunctionDescriptor fdesc) {
-        return LINKER.downcallHandle(fdesc);
-    }
-
-    static MethodHandle downcallHandleVariadic(String name, FunctionDescriptor fdesc) {
-        return SYMBOL_LOOKUP.find(name).
-                map(addr -> VarargsInvoker.make(addr, fdesc)).
-                orElse(null);
-    }
-
-    static MethodHandle upcallHandle(Class<?> fi, String name, FunctionDescriptor fdesc) {
-        try {
-            return MH_LOOKUP.findVirtual(fi, name, fdesc.toMethodType());
-        } catch (Throwable ex) {
-            throw new AssertionError(ex);
-        }
-    }
-
-    static <Z> MemorySegment upcallStub(MethodHandle fiHandle, Z z, FunctionDescriptor fdesc, Arena scope) {
-        try {
-            fiHandle = fiHandle.bindTo(z);
-            return LINKER.upcallStub(fiHandle, fdesc, scope);
-        } catch (Throwable ex) {
-            throw new AssertionError(ex);
-        }
-    }
-
-    static MemorySegment asArray(MemorySegment addr, MemoryLayout layout, int numElements, Arena arena) {
-         return addr.reinterpret(numElements * layout.byteSize(), arena, null);
-    }
-
-    // Internals only below this point
-
-    private static final class VarargsInvoker {
-        private static final MethodHandle INVOKE_MH;
-        private final MemorySegment symbol;
-        private final FunctionDescriptor function;
-
-        private VarargsInvoker(MemorySegment symbol, FunctionDescriptor function) {
-            this.symbol = symbol;
-            this.function = function;
-        }
-
-        static {
-            try {
-                INVOKE_MH = MethodHandles.lookup().findVirtual(VarargsInvoker.class, "invoke", MethodType.methodType(Object.class, SegmentAllocator.class, Object[].class));
-            } catch (ReflectiveOperationException e) {
-                throw new RuntimeException(e);
-            }
-        }
-
-        static MethodHandle make(MemorySegment symbol, FunctionDescriptor function) {
-            VarargsInvoker invoker = new VarargsInvoker(symbol, function);
-            MethodHandle handle = INVOKE_MH.bindTo(invoker).asCollector(Object[].class, function.argumentLayouts().size() + 1);
-            MethodType mtype = MethodType.methodType(function.returnLayout().isPresent() ? carrier(function.returnLayout().get(), true) : void.class);
-            for (MemoryLayout layout : function.argumentLayouts()) {
-                mtype = mtype.appendParameterTypes(carrier(layout, false));
-            }
-            mtype = mtype.appendParameterTypes(Object[].class);
-            boolean needsAllocator = function.returnLayout().isPresent() &&
-                                function.returnLayout().get() instanceof GroupLayout;
-            if (needsAllocator) {
-                mtype = mtype.insertParameterTypes(0, SegmentAllocator.class);
-            } else {
-                handle = MethodHandles.insertArguments(handle, 0, THROWING_ALLOCATOR);
-            }
-            return handle.asType(mtype);
-        }
-
-        static Class<?> carrier(MemoryLayout layout, boolean ret) {
-            if (layout instanceof ValueLayout valueLayout) {
-                return valueLayout.carrier();
-            } else if (layout instanceof GroupLayout) {
-                return MemorySegment.class;
-            } else {
-                throw new AssertionError("Cannot get here!");
-            }
-        }
-
-        private Object invoke(SegmentAllocator allocator, Object[] args) throws Throwable {
-            // one trailing Object[]
-            int nNamedArgs = function.argumentLayouts().size();
-            assert(args.length == nNamedArgs + 1);
-            // The last argument is the array of vararg collector
-            Object[] unnamedArgs = (Object[]) args[args.length - 1];
-
-            int argsCount = nNamedArgs + unnamedArgs.length;
-            Class<?>[] argTypes = new Class<?>[argsCount];
-            MemoryLayout[] argLayouts = new MemoryLayout[nNamedArgs + unnamedArgs.length];
-
-            int pos = 0;
-            for (pos = 0; pos < nNamedArgs; pos++) {
-                argLayouts[pos] = function.argumentLayouts().get(pos);
-            }
-
-            assert pos == nNamedArgs;
-            for (Object o: unnamedArgs) {
-                argLayouts[pos] = variadicLayout(normalize(o.getClass()));
-                pos++;
-            }
-            assert pos == argsCount;
-
-            FunctionDescriptor f = (function.returnLayout().isEmpty()) ?
-                    FunctionDescriptor.ofVoid(argLayouts) :
-                    FunctionDescriptor.of(function.returnLayout().get(), argLayouts);
-            MethodHandle mh = LINKER.downcallHandle(symbol, f);
-            boolean needsAllocator = function.returnLayout().isPresent() &&
-                                            function.returnLayout().get() instanceof GroupLayout;
-            if (needsAllocator) {
-                mh = mh.bindTo(allocator);
-            }
-            // flatten argument list so that it can be passed to an asSpreader MH
-            Object[] allArgs = new Object[nNamedArgs + unnamedArgs.length];
-            System.arraycopy(args, 0, allArgs, 0, nNamedArgs);
-            System.arraycopy(unnamedArgs, 0, allArgs, nNamedArgs, unnamedArgs.length);
-
-            return mh.asSpreader(Object[].class, argsCount).invoke(allArgs);
-        }
-
-        private static Class<?> unboxIfNeeded(Class<?> clazz) {
-            if (clazz == Boolean.class) {
-                return boolean.class;
-            } else if (clazz == Void.class) {
-                return void.class;
-            } else if (clazz == Byte.class) {
-                return byte.class;
-            } else if (clazz == Character.class) {
-                return char.class;
-            } else if (clazz == Short.class) {
-                return short.class;
-            } else if (clazz == Integer.class) {
-                return int.class;
-            } else if (clazz == Long.class) {
-                return long.class;
-            } else if (clazz == Float.class) {
-                return float.class;
-            } else if (clazz == Double.class) {
-                return double.class;
-            } else {
-                return clazz;
-            }
-        }
-
-        private Class<?> promote(Class<?> c) {
-            if (c == byte.class || c == char.class || c == short.class || c == int.class) {
-                return long.class;
-            } else if (c == float.class) {
-                return double.class;
-            } else {
-                return c;
-            }
-        }
-
-        private Class<?> normalize(Class<?> c) {
-            c = unboxIfNeeded(c);
-            if (c.isPrimitive()) {
-                return promote(c);
-            }
-            if (c == MemorySegment.class) {
-                return MemorySegment.class;
-            }
-            throw new IllegalArgumentException("Invalid type for ABI: " + c.getTypeName());
-        }
-
-        private MemoryLayout variadicLayout(Class<?> c) {
-            if (c == long.class) {
-                return JAVA_LONG;
-            } else if (c == double.class) {
-                return JAVA_DOUBLE;
-            } else if (c == MemorySegment.class) {
-                return ADDRESS;
-            } else {
-                throw new IllegalArgumentException("Unhandled variadic argument class: " + c);
-            }
-        }
-    }
-}
diff --git a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/stat/constants$0.java b/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/stat/constants$0.java
deleted file mode 100644
index dffba8a2..00000000
--- a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/stat/constants$0.java
+++ /dev/null
@@ -1,16 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.mac.extr.stat;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$0 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$0() {}
-}
-
-
diff --git a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/stat/stat_h.java b/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/stat/stat_h.java
index ec133788..785d4477 100644
--- a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/stat/stat_h.java
+++ b/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/stat/stat_h.java
@@ -2,37 +2,89 @@
 
 package org.cryptomator.jfuse.mac.extr.stat;
 
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
+import java.lang.invoke.*;
 import java.lang.foreign.*;
+import java.nio.ByteOrder;
+import java.util.*;
+import java.util.function.*;
+import java.util.stream.*;
+
 import static java.lang.foreign.ValueLayout.*;
-public class stat_h  {
-
-    public static final OfByte C_CHAR = JAVA_BYTE;
-    public static final OfShort C_SHORT = JAVA_SHORT;
-    public static final OfInt C_INT = JAVA_INT;
-    public static final OfLong C_LONG = JAVA_LONG;
-    public static final OfLong C_LONG_LONG = JAVA_LONG;
-    public static final OfFloat C_FLOAT = JAVA_FLOAT;
-    public static final OfDouble C_DOUBLE = JAVA_DOUBLE;
-    public static final AddressLayout C_POINTER = RuntimeHelper.POINTER;
+import static java.lang.foreign.MemoryLayout.PathElement.*;
+
+public class stat_h {
+
+    stat_h() {
+        // Should not be called directly
+    }
+
+    static final Arena LIBRARY_ARENA = Arena.ofAuto();
+    static final boolean TRACE_DOWNCALLS = Boolean.getBoolean("jextract.trace.downcalls");
+
+    static void traceDowncall(String name, Object... args) {
+         String traceArgs = Arrays.stream(args)
+                       .map(Object::toString)
+                       .collect(Collectors.joining(", "));
+         System.out.printf("%s(%s)\n", name, traceArgs);
+    }
+
+    static MemorySegment findOrThrow(String symbol) {
+        return SYMBOL_LOOKUP.find(symbol)
+            .orElseThrow(() -> new UnsatisfiedLinkError("unresolved symbol: " + symbol));
+    }
+
+    static MethodHandle upcallHandle(Class<?> fi, String name, FunctionDescriptor fdesc) {
+        try {
+            return MethodHandles.lookup().findVirtual(fi, name, fdesc.toMethodType());
+        } catch (ReflectiveOperationException ex) {
+            throw new AssertionError(ex);
+        }
+    }
+
+    static MemoryLayout align(MemoryLayout layout, long align) {
+        return switch (layout) {
+            case PaddingLayout p -> p;
+            case ValueLayout v -> v.withByteAlignment(align);
+            case GroupLayout g -> {
+                MemoryLayout[] alignedMembers = g.memberLayouts().stream()
+                        .map(m -> align(m, align)).toArray(MemoryLayout[]::new);
+                yield g instanceof StructLayout ?
+                        MemoryLayout.structLayout(alignedMembers) : MemoryLayout.unionLayout(alignedMembers);
+            }
+            case SequenceLayout s -> MemoryLayout.sequenceLayout(s.elementCount(), align(s.elementLayout(), align));
+        };
+    }
+
+    static final SymbolLookup SYMBOL_LOOKUP = SymbolLookup.loaderLookup()
+            .or(Linker.nativeLinker().defaultLookup());
+
+    public static final ValueLayout.OfBoolean C_BOOL = ValueLayout.JAVA_BOOLEAN;
+    public static final ValueLayout.OfByte C_CHAR = ValueLayout.JAVA_BYTE;
+    public static final ValueLayout.OfShort C_SHORT = ValueLayout.JAVA_SHORT;
+    public static final ValueLayout.OfInt C_INT = ValueLayout.JAVA_INT;
+    public static final ValueLayout.OfLong C_LONG_LONG = ValueLayout.JAVA_LONG;
+    public static final ValueLayout.OfFloat C_FLOAT = ValueLayout.JAVA_FLOAT;
+    public static final ValueLayout.OfDouble C_DOUBLE = ValueLayout.JAVA_DOUBLE;
+    public static final AddressLayout C_POINTER = ValueLayout.ADDRESS
+            .withTargetLayout(MemoryLayout.sequenceLayout(java.lang.Long.MAX_VALUE, JAVA_BYTE));
+    public static final ValueLayout.OfLong C_LONG = ValueLayout.JAVA_LONG;
+    private static final int UTIME_NOW = (int)-1L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define UTIME_NOW -1
      * }
      */
     public static int UTIME_NOW() {
-        return (int)-1L;
+        return UTIME_NOW;
     }
+    private static final int UTIME_OMIT = (int)-2L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define UTIME_OMIT -2
      * }
      */
     public static int UTIME_OMIT() {
-        return (int)-2L;
+        return UTIME_OMIT;
     }
 }
 
-
diff --git a/jfuse-mac/src/test/java/org/cryptomator/jfuse/mac/FileInfoImplTest.java b/jfuse-mac/src/test/java/org/cryptomator/jfuse/mac/FileInfoImplTest.java
index 6ee83401..91fee183 100644
--- a/jfuse-mac/src/test/java/org/cryptomator/jfuse/mac/FileInfoImplTest.java
+++ b/jfuse-mac/src/test/java/org/cryptomator/jfuse/mac/FileInfoImplTest.java
@@ -22,7 +22,7 @@ public class FileInfoImplTest {
 	public void testGetOpenFlags(int flags, Set<OpenOption> expectedResult) {
 		try (var arena = Arena.ofConfined()) {
 			var fi = new FileInfoImpl(fuse_file_info.allocate(arena));
-			fuse_file_info.flags$set(fi.segment(), flags);
+			fuse_file_info.flags(fi.segment(), flags);
 
 			var result = fi.getOpenFlags();
 
diff --git a/jfuse-mac/src/test/java/org/cryptomator/jfuse/mac/FuseConnInfoImplTest.java b/jfuse-mac/src/test/java/org/cryptomator/jfuse/mac/FuseConnInfoImplTest.java
index 12347845..0590dea0 100644
--- a/jfuse-mac/src/test/java/org/cryptomator/jfuse/mac/FuseConnInfoImplTest.java
+++ b/jfuse-mac/src/test/java/org/cryptomator/jfuse/mac/FuseConnInfoImplTest.java
@@ -23,7 +23,7 @@ public class FuseConnInfoImplTest {
 	public void testGetters(SetInMemorySegment setter, GetInConnInfo getter) {
 		try (var arena = Arena.ofConfined()) {
 			var segment = fuse_conn_info.allocate(arena);
-			var connInfo = new FuseConnInfoImpl(segment, arena);
+			var connInfo = new FuseConnInfoImpl(segment);
 
 			setter.accept(segment, 42);
 
@@ -33,15 +33,15 @@ public void testGetters(SetInMemorySegment setter, GetInConnInfo getter) {
 
 	public static Stream<Arguments> testGetters() {
 		return Stream.of(
-				Arguments.arguments((SetInMemorySegment) fuse_conn_info::proto_major$set, Named.of("protoMajor()", (GetInConnInfo) FuseConnInfo::protoMajor)),
-				Arguments.arguments((SetInMemorySegment) fuse_conn_info::proto_minor$set, Named.of("protoMinor()", (GetInConnInfo) FuseConnInfo::protoMinor)),
-				Arguments.arguments((SetInMemorySegment) fuse_conn_info::capable$set, Named.of("capable()", (GetInConnInfo) FuseConnInfo::capable)),
-				Arguments.arguments((SetInMemorySegment) fuse_conn_info::max_write$set, Named.of("maxWrite()", (GetInConnInfo) FuseConnInfo::maxWrite)),
-				Arguments.arguments((SetInMemorySegment) fuse_conn_info::max_readahead$set, Named.of("maxReadahead()", (GetInConnInfo) FuseConnInfo::maxReadahead)),
-				Arguments.arguments((SetInMemorySegment) fuse_conn_info::max_background$set, Named.of("maxBackground()", (GetInConnInfo) FuseConnInfo::maxBackground)),
-				Arguments.arguments((SetInMemorySegment) fuse_conn_info::congestion_threshold$set, Named.of("congestionThreshold()", (GetInConnInfo) FuseConnInfo::congestionThreshold)),
-				Arguments.arguments((SetInMemorySegment) fuse_conn_info::async_read$set, Named.of("asyncRead()", (GetInConnInfo) FuseConnInfo::asyncRead)),
-				Arguments.arguments((SetInMemorySegment) fuse_conn_info::want$set, Named.of("want()", (GetInConnInfo) FuseConnInfo::want))
+				Arguments.arguments((SetInMemorySegment) fuse_conn_info::proto_major, Named.of("protoMajor()", (GetInConnInfo) FuseConnInfo::protoMajor)),
+				Arguments.arguments((SetInMemorySegment) fuse_conn_info::proto_minor, Named.of("protoMinor()", (GetInConnInfo) FuseConnInfo::protoMinor)),
+				Arguments.arguments((SetInMemorySegment) fuse_conn_info::capable, Named.of("capable()", (GetInConnInfo) FuseConnInfo::capable)),
+				Arguments.arguments((SetInMemorySegment) fuse_conn_info::max_write, Named.of("maxWrite()", (GetInConnInfo) FuseConnInfo::maxWrite)),
+				Arguments.arguments((SetInMemorySegment) fuse_conn_info::max_readahead, Named.of("maxReadahead()", (GetInConnInfo) FuseConnInfo::maxReadahead)),
+				Arguments.arguments((SetInMemorySegment) fuse_conn_info::max_background, Named.of("maxBackground()", (GetInConnInfo) FuseConnInfo::maxBackground)),
+				Arguments.arguments((SetInMemorySegment) fuse_conn_info::congestion_threshold, Named.of("congestionThreshold()", (GetInConnInfo) FuseConnInfo::congestionThreshold)),
+				Arguments.arguments((SetInMemorySegment) fuse_conn_info::async_read, Named.of("asyncRead()", (GetInConnInfo) FuseConnInfo::asyncRead)),
+				Arguments.arguments((SetInMemorySegment) fuse_conn_info::want, Named.of("want()", (GetInConnInfo) FuseConnInfo::want))
 		);
 	}
 
@@ -55,7 +55,7 @@ private interface GetInConnInfo extends Function<FuseConnInfo, Integer> {}
 	public void testSetters(SetInConnInfo setter, GetInMemorySegment getter) {
 		try (var arena = Arena.ofConfined()) {
 			var segment = fuse_conn_info.allocate(arena);
-			var connInfo = new FuseConnInfoImpl(segment, arena);
+			var connInfo = new FuseConnInfoImpl(segment);
 
 			setter.accept(connInfo, 42);
 
@@ -65,12 +65,12 @@ public void testSetters(SetInConnInfo setter, GetInMemorySegment getter) {
 
 	public static Stream<Arguments> testSetters() {
 		return Stream.of(
-				Arguments.arguments(Named.of("setWant()", (SetInConnInfo) FuseConnInfo::setWant), (GetInMemorySegment) fuse_conn_info::want$get),
-				Arguments.arguments(Named.of("setMaxWrite()", (SetInConnInfo) FuseConnInfo::setMaxWrite), (GetInMemorySegment) fuse_conn_info::max_write$get),
-				Arguments.arguments(Named.of("setMaxReadahead()", (SetInConnInfo) FuseConnInfo::setMaxReadahead), (GetInMemorySegment) fuse_conn_info::max_readahead$get),
-				Arguments.arguments(Named.of("setMaxBackground()", (SetInConnInfo) FuseConnInfo::setMaxBackground), (GetInMemorySegment) fuse_conn_info::max_background$get),
-				Arguments.arguments(Named.of("setCongestionThreshold()", (SetInConnInfo) FuseConnInfo::setCongestionThreshold), (GetInMemorySegment) fuse_conn_info::congestion_threshold$get),
-				Arguments.arguments(Named.of("setAsyncRead()", (SetInConnInfo) FuseConnInfo::setAsyncRead), (GetInMemorySegment) fuse_conn_info::async_read$get)
+				Arguments.arguments(Named.of("setWant()", (SetInConnInfo) FuseConnInfo::setWant), (GetInMemorySegment) fuse_conn_info::want),
+				Arguments.arguments(Named.of("setMaxWrite()", (SetInConnInfo) FuseConnInfo::setMaxWrite), (GetInMemorySegment) fuse_conn_info::max_write),
+				Arguments.arguments(Named.of("setMaxReadahead()", (SetInConnInfo) FuseConnInfo::setMaxReadahead), (GetInMemorySegment) fuse_conn_info::max_readahead),
+				Arguments.arguments(Named.of("setMaxBackground()", (SetInConnInfo) FuseConnInfo::setMaxBackground), (GetInMemorySegment) fuse_conn_info::max_background),
+				Arguments.arguments(Named.of("setCongestionThreshold()", (SetInConnInfo) FuseConnInfo::setCongestionThreshold), (GetInMemorySegment) fuse_conn_info::congestion_threshold),
+				Arguments.arguments(Named.of("setAsyncRead()", (SetInConnInfo) FuseConnInfo::setAsyncRead), (GetInMemorySegment) fuse_conn_info::async_read)
 		);
 	}
 
diff --git a/jfuse-mac/src/test/java/org/cryptomator/jfuse/mac/FuseImplTest.java b/jfuse-mac/src/test/java/org/cryptomator/jfuse/mac/FuseImplTest.java
index 9fbf5d0b..dffc2683 100644
--- a/jfuse-mac/src/test/java/org/cryptomator/jfuse/mac/FuseImplTest.java
+++ b/jfuse-mac/src/test/java/org/cryptomator/jfuse/mac/FuseImplTest.java
@@ -84,7 +84,7 @@ public void testParseArgs() {
 				MemorySegment mp = invocation.getArgument(1);
 				MemorySegment mt = invocation.getArgument(2);
 				MemorySegment fg = invocation.getArgument(3);
-				mp.set(ValueLayout.ADDRESS, 0L, arena.allocateUtf8String("/mount/point"));
+				mp.set(ValueLayout.ADDRESS, 0L, arena.allocateFrom("/mount/point"));
 				mt.set(JAVA_INT, 0L, 1);
 				fg.set(JAVA_INT, 0L, 1);
 				return 0;
@@ -108,7 +108,7 @@ public class FlushFsyncFsyncdir {
 		@DisplayName("flush(\"/foo\", fi)")
 		public void testFlush() {
 			try (var arena = Arena.ofConfined()) {
-				var path = arena.allocateUtf8String("/foo");
+				var path = arena.allocateFrom("/foo");
 				var fi = fuse_file_info.allocate(arena);
 				Mockito.doReturn(42).when(fuseOps).flush(Mockito.eq("/foo"), Mockito.any());
 
@@ -122,7 +122,7 @@ public void testFlush() {
 		@DisplayName("fsync(\"/foo\", 1, fi)")
 		public void testFsync() {
 			try (var arena = Arena.ofConfined()) {
-				var path = arena.allocateUtf8String("/foo");
+				var path = arena.allocateFrom("/foo");
 				var fi = fuse_file_info.allocate(arena);
 				Mockito.doReturn(42).when(fuseOps).fsync(Mockito.eq("/foo"), Mockito.eq(1), Mockito.any());
 
@@ -136,7 +136,7 @@ public void testFsync() {
 		@DisplayName("fsyncdir(\"/foo\", 1, fi)")
 		public void testFsyncdir() {
 			try (var arena = Arena.ofConfined()) {
-				var path = arena.allocateUtf8String("/foo");
+				var path = arena.allocateFrom("/foo");
 				var fi = fuse_file_info.allocate(arena);
 				Mockito.doReturn(42).when(fuseOps).fsyncdir(Mockito.eq("/foo"), Mockito.eq(1), Mockito.any());
 
@@ -156,7 +156,7 @@ public class Utimens {
 		@Test
 		public void testUtimensNow() {
 			try (var arena = Arena.ofConfined()) {
-				var path = arena.allocateUtf8String("/foo");
+				var path = arena.allocateFrom("/foo");
 				var times = MemorySegment.NULL;
 				Mockito.doReturn(42).when(fuseOps).utimens(Mockito.eq("/foo"), Mockito.argThat(TimeSpec::isUtimeNow), Mockito.argThat(TimeSpec::isUtimeNow), Mockito.isNull());
 
@@ -176,12 +176,12 @@ public void testUtimens(long sec0, long nsec0, long sec1, long nsec1) {
 			Instant expectedATime = Instant.ofEpochSecond(sec0, nsec0);
 			Instant expectedMTime = Instant.ofEpochSecond(sec1, nsec1);
 			try (var arena = Arena.ofConfined()) {
-				var path = arena.allocateUtf8String("/foo");
+				var path = arena.allocateFrom("/foo");
 				var times = timespec.allocateArray(2, arena);
-				timespec.tv_sec$set(times, 0, sec0);
-				timespec.tv_nsec$set(times, 0, nsec0);
-				timespec.tv_sec$set(times, 1, sec1);
-				timespec.tv_nsec$set(times, 1, nsec1);
+				timespec.tv_sec(timespec.asSlice(times, 0), sec0);
+				timespec.tv_nsec(timespec.asSlice(times, 0), nsec0);
+				timespec.tv_sec(timespec.asSlice(times, 1), sec1);
+				timespec.tv_nsec(timespec.asSlice(times, 1), nsec1);
 				Mockito.doReturn(42).when(fuseOps).utimens(Mockito.eq("/foo"), Mockito.argThat(t -> expectedATime.equals(t.get())), Mockito.argThat(t -> expectedMTime.equals(t.get())), Mockito.isNull());
 
 				var result = fuseImpl.utimens(path, times);
@@ -199,7 +199,7 @@ public class Attr {
 		@DisplayName("getattr")
 		public void testGetattr() {
 			try (var arena = Arena.ofConfined()) {
-				var path = arena.allocateUtf8String("/foo");
+				var path = arena.allocateFrom("/foo");
 				var attr = stat.allocate(arena);
 				Mockito.doReturn(42).when(fuseOps).getattr(Mockito.eq("/foo"), Mockito.any(), Mockito.isNull());
 
@@ -213,7 +213,7 @@ public void testGetattr() {
 		@DisplayName("fgetattr")
 		public void testFgetattr() {
 			try (var arena = Arena.ofConfined()) {
-				var path = arena.allocateUtf8String("/foo");
+				var path = arena.allocateFrom("/foo");
 				var attr = stat.allocate(arena);
 				var fi = fuse_file_info.allocate(arena);
 				Mockito.doReturn(42).when(fuseOps).getattr(Mockito.eq("/foo"), Mockito.any(), Mockito.notNull());
@@ -228,8 +228,8 @@ public void testFgetattr() {
 		@DisplayName("getxattr")
 		public void testGetxattr() {
 			try (var arena = Arena.ofConfined()) {
-				var path = arena.allocateUtf8String("/foo");
-				var name = arena.allocateUtf8String("bar");
+				var path = arena.allocateFrom("/foo");
+				var name = arena.allocateFrom("bar");
 				var value = arena.allocate(100);
 
 				Mockito.doReturn(42).when(fuseOps).getxattr(Mockito.eq("/foo"), Mockito.eq("bar"), Mockito.any());
@@ -244,8 +244,8 @@ public void testGetxattr() {
 		@DisplayName("setxattr")
 		public void testSetxattr() {
 			try (var arena = Arena.ofConfined()) {
-				var path = arena.allocateUtf8String("/foo");
-				var name = arena.allocateUtf8String("bar");
+				var path = arena.allocateFrom("/foo");
+				var name = arena.allocateFrom("bar");
 				var value = arena.allocate(100);
 
 				Mockito.doReturn(42).when(fuseOps).setxattr(Mockito.eq("/foo"), Mockito.eq("bar"), Mockito.any(), Mockito.anyInt());
@@ -260,7 +260,7 @@ public void testSetxattr() {
 		@DisplayName("listxattr")
 		public void testListxattr() {
 			try (var arena = Arena.ofConfined()) {
-				var path = arena.allocateUtf8String("/foo");
+				var path = arena.allocateFrom("/foo");
 				var list = arena.allocate(100);
 
 				Mockito.doReturn(42).when(fuseOps).listxattr(Mockito.eq("/foo"), Mockito.any());
@@ -275,8 +275,8 @@ public void testListxattr() {
 		@DisplayName("removexattr")
 		public void testRemovexattr() {
 			try (var arena = Arena.ofConfined()) {
-				var path = arena.allocateUtf8String("/foo");
-				var name = arena.allocateUtf8String("bar");
+				var path = arena.allocateFrom("/foo");
+				var name = arena.allocateFrom("bar");
 
 				Mockito.doReturn(42).when(fuseOps).removexattr(Mockito.eq("/foo"), Mockito.eq("bar"));
 
@@ -296,7 +296,7 @@ public class Truncate {
 		@DisplayName("truncate")
 		public void testTruncate() {
 			try (var arena = Arena.ofConfined()) {
-				var path = arena.allocateUtf8String("/foo");
+				var path = arena.allocateFrom("/foo");
 				Mockito.doReturn(42).when(fuseOps).truncate(Mockito.eq("/foo"), Mockito.eq(1337L), Mockito.isNull());
 
 				var result = fuseImpl.truncate(path, 1337L);
@@ -309,7 +309,7 @@ public void testTruncate() {
 		@DisplayName("ftruncate")
 		public void testFtruncate() {
 			try (var arena = Arena.ofConfined()) {
-				var path = arena.allocateUtf8String("/foo");
+				var path = arena.allocateFrom("/foo");
 				var fi = fuse_file_info.allocate(arena);
 				Mockito.doReturn(42).when(fuseOps).truncate(Mockito.eq("/foo"), Mockito.eq(1337L), Mockito.notNull());
 
@@ -325,7 +325,7 @@ public void testFtruncate() {
 	@DisplayName("chown")
 	public void testChown() {
 		try (var arena = Arena.ofConfined()) {
-			var path = arena.allocateUtf8String("/foo");
+			var path = arena.allocateFrom("/foo");
 			Mockito.doReturn(42).when(fuseOps).chown("/foo", 42, 1337, null);
 
 			var result = fuseImpl.chown(path, 42, 1337);
diff --git a/jfuse-mac/src/test/java/org/cryptomator/jfuse/mac/StatImplTest.java b/jfuse-mac/src/test/java/org/cryptomator/jfuse/mac/StatImplTest.java
index 8bf87467..b69f6220 100644
--- a/jfuse-mac/src/test/java/org/cryptomator/jfuse/mac/StatImplTest.java
+++ b/jfuse-mac/src/test/java/org/cryptomator/jfuse/mac/StatImplTest.java
@@ -23,7 +23,7 @@ public class StatImplTest {
 	public void testGetters(SetInMemorySegment<Number> setter, GetInStat<Number> getter, Number value) {
 		try (var arena = Arena.ofConfined()) {
 			var segment = stat.allocate(arena);
-			var stat = new StatImpl(segment, arena);
+			var stat = new StatImpl(segment);
 
 			setter.accept(segment, value);
 
@@ -33,11 +33,11 @@ public void testGetters(SetInMemorySegment<Number> setter, GetInStat<Number> get
 
 	public static Stream<Arguments> testGetters() {
 		return Stream.of(
-				Arguments.arguments((SetInMemorySegment<Short>) stat::st_mode$set, Named.of("getMode()", (GetInStat<Integer>) Stat::getMode), (short) 42),
-				Arguments.arguments((SetInMemorySegment<Integer>) stat::st_uid$set, Named.of("getUid()", (GetInStat<Integer>) Stat::getUid), 42),
-				Arguments.arguments((SetInMemorySegment<Integer>) stat::st_gid$set, Named.of("getGid()", (GetInStat<Integer>) Stat::getGid), 42),
-				Arguments.arguments((SetInMemorySegment<Short>) stat::st_nlink$set, Named.of("getNLink()", (GetInStat<Long>) Stat::getNLink), (short) 42),
-				Arguments.arguments((SetInMemorySegment<Long>) stat::st_size$set, Named.of("getSize()", (GetInStat<Long>) Stat::getSize), 42L)
+				Arguments.arguments((SetInMemorySegment<Short>) stat::st_mode, Named.of("getMode()", (GetInStat<Integer>) Stat::getMode), (short) 42),
+				Arguments.arguments((SetInMemorySegment<Integer>) stat::st_uid, Named.of("getUid()", (GetInStat<Integer>) Stat::getUid), 42),
+				Arguments.arguments((SetInMemorySegment<Integer>) stat::st_gid, Named.of("getGid()", (GetInStat<Integer>) Stat::getGid), 42),
+				Arguments.arguments((SetInMemorySegment<Short>) stat::st_nlink, Named.of("getNLink()", (GetInStat<Long>) Stat::getNLink), (short) 42),
+				Arguments.arguments((SetInMemorySegment<Long>) stat::st_size, Named.of("getSize()", (GetInStat<Long>) Stat::getSize), 42L)
 		);
 	}
 
@@ -51,7 +51,7 @@ private interface GetInStat<T> extends Function<Stat, T> {}
 	public void testSetters(SetInStat<Number> setter, GetInMemorySegment<Number> getter, Number value) {
 		try (var arena = Arena.ofConfined()) {
 			var segment = stat.allocate(arena);
-			var stat = new StatImpl(segment, arena);
+			var stat = new StatImpl(segment);
 
 			setter.accept(stat, value);
 
@@ -61,11 +61,11 @@ public void testSetters(SetInStat<Number> setter, GetInMemorySegment<Number> get
 
 	public static Stream<Arguments> testSetters() {
 		return Stream.of(
-				Arguments.arguments(Named.of("setMode()", (SetInStat<Integer>) Stat::setMode), (GetInMemorySegment<Short>) stat::st_mode$get, 42),
-				Arguments.arguments(Named.of("setUid()", (SetInStat<Integer>) Stat::setUid), (GetInMemorySegment<Integer>) stat::st_uid$get, 42),
-				Arguments.arguments(Named.of("setGid()", (SetInStat<Integer>) Stat::setGid), (GetInMemorySegment<Integer>) stat::st_gid$get, 42),
-				Arguments.arguments(Named.of("setNLink()", (SetInStat<Short>) Stat::setNLink), (GetInMemorySegment<Short>) stat::st_nlink$get, (short) 42),
-				Arguments.arguments(Named.of("setSize()", (SetInStat<Long>) Stat::setSize), (GetInMemorySegment<Long>) stat::st_size$get, 42L)
+				Arguments.arguments(Named.of("setMode()", (SetInStat<Integer>) Stat::setMode), (GetInMemorySegment<Short>) stat::st_mode, 42),
+				Arguments.arguments(Named.of("setUid()", (SetInStat<Integer>) Stat::setUid), (GetInMemorySegment<Integer>) stat::st_uid, 42),
+				Arguments.arguments(Named.of("setGid()", (SetInStat<Integer>) Stat::setGid), (GetInMemorySegment<Integer>) stat::st_gid, 42),
+				Arguments.arguments(Named.of("setNLink()", (SetInStat<Short>) Stat::setNLink), (GetInMemorySegment<Short>) stat::st_nlink, (short) 42),
+				Arguments.arguments(Named.of("setSize()", (SetInStat<Long>) Stat::setSize), (GetInMemorySegment<Long>) stat::st_size, 42L)
 		);
 	}
 
diff --git a/jfuse-mac/src/test/java/org/cryptomator/jfuse/mac/StatvfsImplTest.java b/jfuse-mac/src/test/java/org/cryptomator/jfuse/mac/StatvfsImplTest.java
index 4ecb1c2c..fe1fe986 100644
--- a/jfuse-mac/src/test/java/org/cryptomator/jfuse/mac/StatvfsImplTest.java
+++ b/jfuse-mac/src/test/java/org/cryptomator/jfuse/mac/StatvfsImplTest.java
@@ -23,7 +23,7 @@ public class StatvfsImplTest {
 	public void testGetters(SetInMemorySegment<Number> setter, GetInStatvfs<Number> getter, Number value, long expected) {
 		try (var arena = Arena.ofConfined()) {
 			var segment = statvfs.allocate(arena);
-			var statvfs = new StatvfsImpl(segment, arena);
+			var statvfs = new StatvfsImpl(segment);
 
 			setter.accept(segment, value);
 
@@ -33,17 +33,17 @@ public void testGetters(SetInMemorySegment<Number> setter, GetInStatvfs<Number>
 
 	public static Stream<Arguments> testGetters() {
 		return Stream.of(
-				Arguments.arguments((SetInMemorySegment<Long>) statvfs::f_bsize$set, Named.of("getBsize()", (GetInStatvfs<Long>) Statvfs::getBsize), 42L, 42L),
-				Arguments.arguments((SetInMemorySegment<Long>) statvfs::f_frsize$set, Named.of("getFrsize()", (GetInStatvfs<Long>) Statvfs::getFrsize), 42L, 42L),
-				Arguments.arguments((SetInMemorySegment<Long>) statvfs::f_namemax$set, Named.of("getNameMax()", (GetInStatvfs<Long>) Statvfs::getNameMax), 42L, 42L),
+				Arguments.arguments((SetInMemorySegment<Long>) statvfs::f_bsize, Named.of("getBsize()", (GetInStatvfs<Long>) Statvfs::getBsize), 42L, 42L),
+				Arguments.arguments((SetInMemorySegment<Long>) statvfs::f_frsize, Named.of("getFrsize()", (GetInStatvfs<Long>) Statvfs::getFrsize), 42L, 42L),
+				Arguments.arguments((SetInMemorySegment<Long>) statvfs::f_namemax, Named.of("getNameMax()", (GetInStatvfs<Long>) Statvfs::getNameMax), 42L, 42L),
 
-				Arguments.arguments((SetInMemorySegment<Integer>) statvfs::f_blocks$set, Named.of("getBlocks() with memory containing value < INT32", (GetInStatvfs<Long>) Statvfs::getBlocks), 42, 42L),
-				Arguments.arguments((SetInMemorySegment<Integer>) statvfs::f_bfree$set, Named.of("getBfree() with memory containing value < INT32", (GetInStatvfs<Long>) Statvfs::getBfree), 42, 42L),
-				Arguments.arguments((SetInMemorySegment<Integer>) statvfs::f_bavail$set, Named.of("getBavail() with memory containing value < INT32", (GetInStatvfs<Long>) Statvfs::getBavail), 42, 42L),
+				Arguments.arguments((SetInMemorySegment<Integer>) statvfs::f_blocks, Named.of("getBlocks() with memory containing value < INT32", (GetInStatvfs<Long>) Statvfs::getBlocks), 42, 42L),
+				Arguments.arguments((SetInMemorySegment<Integer>) statvfs::f_bfree, Named.of("getBfree() with memory containing value < INT32", (GetInStatvfs<Long>) Statvfs::getBfree), 42, 42L),
+				Arguments.arguments((SetInMemorySegment<Integer>) statvfs::f_bavail, Named.of("getBavail() with memory containing value < INT32", (GetInStatvfs<Long>) Statvfs::getBavail), 42, 42L),
 
-				Arguments.arguments((SetInMemorySegment<Integer>) statvfs::f_blocks$set, Named.of("getBlocks() with memory containing value < UINT32", (GetInStatvfs<Long>) Statvfs::getBlocks), 0xFFFFFFD6, 0x00000000_FFFFFFD6L),
-				Arguments.arguments((SetInMemorySegment<Integer>) statvfs::f_bfree$set, Named.of("getBfree() with memory containing value < UINT32", (GetInStatvfs<Long>) Statvfs::getBfree), 0xFFFFFFD6, 0x00000000_FFFFFFD6L),
-				Arguments.arguments((SetInMemorySegment<Integer>) statvfs::f_bavail$set, Named.of("getBavail() with memory containing value < UINT32", (GetInStatvfs<Long>) Statvfs::getBavail), 0xFFFFFFD6, 0x00000000_FFFFFFD6L)
+				Arguments.arguments((SetInMemorySegment<Integer>) statvfs::f_blocks, Named.of("getBlocks() with memory containing value < UINT32", (GetInStatvfs<Long>) Statvfs::getBlocks), 0xFFFFFFD6, 0x00000000_FFFFFFD6L),
+				Arguments.arguments((SetInMemorySegment<Integer>) statvfs::f_bfree, Named.of("getBfree() with memory containing value < UINT32", (GetInStatvfs<Long>) Statvfs::getBfree), 0xFFFFFFD6, 0x00000000_FFFFFFD6L),
+				Arguments.arguments((SetInMemorySegment<Integer>) statvfs::f_bavail, Named.of("getBavail() with memory containing value < UINT32", (GetInStatvfs<Long>) Statvfs::getBavail), 0xFFFFFFD6, 0x00000000_FFFFFFD6L)
 		);
 	}
 
@@ -59,7 +59,7 @@ private interface GetInStatvfs<T> extends Function<Statvfs, T> {
 	public void testSetters(SetInStatvfs<Number> setter, GetInMemorySegment<Number> getter, Number value, long expected) {
 		try (var arena = Arena.ofConfined()) {
 			var segment = statvfs.allocate(arena);
-			var statvfs = new StatvfsImpl(segment, arena);
+			var statvfs = new StatvfsImpl(segment);
 
 			setter.accept(statvfs, value.longValue());
 
@@ -69,21 +69,21 @@ public void testSetters(SetInStatvfs<Number> setter, GetInMemorySegment<Number>
 
 	public static Stream<Arguments> testSetters() {
 		return Stream.of(
-				Arguments.arguments(Named.of("setBsize()", (SetInStatvfs<Long>) Statvfs::setBsize), (GetInMemorySegment<Long>) statvfs::f_bsize$get, 42L, 42L),
-				Arguments.arguments(Named.of("setFrsize()", (SetInStatvfs<Long>) Statvfs::setFrsize), (GetInMemorySegment<Long>) statvfs::f_frsize$get, 42L, 42L),
-				Arguments.arguments(Named.of("setNameMax()", (SetInStatvfs<Long>) Statvfs::setNameMax), (GetInMemorySegment<Long>) statvfs::f_namemax$get, 42L, 42L),
+				Arguments.arguments(Named.of("setBsize()", (SetInStatvfs<Long>) Statvfs::setBsize), (GetInMemorySegment<Long>) statvfs::f_bsize, 42L, 42L),
+				Arguments.arguments(Named.of("setFrsize()", (SetInStatvfs<Long>) Statvfs::setFrsize), (GetInMemorySegment<Long>) statvfs::f_frsize, 42L, 42L),
+				Arguments.arguments(Named.of("setNameMax()", (SetInStatvfs<Long>) Statvfs::setNameMax), (GetInMemorySegment<Long>) statvfs::f_namemax, 42L, 42L),
 
-				Arguments.arguments(Named.of("setBlocks(i) with i < INT32", (SetInStatvfs<Long>) Statvfs::setBlocks), (GetInMemorySegment<Integer>) statvfs::f_blocks$get, 42, 42),
-				Arguments.arguments(Named.of("setBfree(i) with i < INT32", (SetInStatvfs<Long>) Statvfs::setBfree), (GetInMemorySegment<Integer>) statvfs::f_bfree$get, 42, 42),
-				Arguments.arguments(Named.of("setBavail(i) with i < INT32", (SetInStatvfs<Long>) Statvfs::setBavail), (GetInMemorySegment<Integer>) statvfs::f_bavail$get, 42, 42),
+				Arguments.arguments(Named.of("setBlocks(i) with i < INT32", (SetInStatvfs<Long>) Statvfs::setBlocks), (GetInMemorySegment<Integer>) statvfs::f_blocks, 42, 42),
+				Arguments.arguments(Named.of("setBfree(i) with i < INT32", (SetInStatvfs<Long>) Statvfs::setBfree), (GetInMemorySegment<Integer>) statvfs::f_bfree, 42, 42),
+				Arguments.arguments(Named.of("setBavail(i) with i < INT32", (SetInStatvfs<Long>) Statvfs::setBavail), (GetInMemorySegment<Integer>) statvfs::f_bavail, 42, 42),
 
-				Arguments.arguments(Named.of("setBlocks(i) with i > INT32", (SetInStatvfs<Long>) Statvfs::setBlocks), (GetInMemorySegment<Integer>) statvfs::f_blocks$get, 0xFFFFFFD6, 0xFFFFFFD6),
-				Arguments.arguments(Named.of("setBfree(i) with i > INT32", (SetInStatvfs<Long>) Statvfs::setBfree), (GetInMemorySegment<Integer>) statvfs::f_bfree$get, 0xFFFFFFD6, 0xFFFFFFD6),
-				Arguments.arguments(Named.of("setBavail(i) with i > INT32", (SetInStatvfs<Long>) Statvfs::setBavail), (GetInMemorySegment<Integer>) statvfs::f_bavail$get, 0xFFFFFFD6, 0xFFFFFFD6),
+				Arguments.arguments(Named.of("setBlocks(i) with i > INT32", (SetInStatvfs<Long>) Statvfs::setBlocks), (GetInMemorySegment<Integer>) statvfs::f_blocks, 0xFFFFFFD6, 0xFFFFFFD6),
+				Arguments.arguments(Named.of("setBfree(i) with i > INT32", (SetInStatvfs<Long>) Statvfs::setBfree), (GetInMemorySegment<Integer>) statvfs::f_bfree, 0xFFFFFFD6, 0xFFFFFFD6),
+				Arguments.arguments(Named.of("setBavail(i) with i > INT32", (SetInStatvfs<Long>) Statvfs::setBavail), (GetInMemorySegment<Integer>) statvfs::f_bavail, 0xFFFFFFD6, 0xFFFFFFD6),
 
-				Arguments.arguments(Named.of("setBlocks(i) with i > UINT32", (SetInStatvfs<Long>) Statvfs::setBlocks), (GetInMemorySegment<Integer>) statvfs::f_blocks$get, 0x01234567_89ABCDEFL, 0xFFFFFFFF),
-				Arguments.arguments(Named.of("setBfree(i) with i > UINT32", (SetInStatvfs<Long>) Statvfs::setBfree), (GetInMemorySegment<Integer>) statvfs::f_bfree$get, 0x01234567_89ABCDEFL, 0xFFFFFFFF),
-				Arguments.arguments(Named.of("setBavail(i) with i > UINT32", (SetInStatvfs<Long>) Statvfs::setBavail), (GetInMemorySegment<Integer>) statvfs::f_bavail$get, 0x01234567_89ABCDEFL, 0xFFFFFFFF)
+				Arguments.arguments(Named.of("setBlocks(i) with i > UINT32", (SetInStatvfs<Long>) Statvfs::setBlocks), (GetInMemorySegment<Integer>) statvfs::f_blocks, 0x01234567_89ABCDEFL, 0xFFFFFFFF),
+				Arguments.arguments(Named.of("setBfree(i) with i > UINT32", (SetInStatvfs<Long>) Statvfs::setBfree), (GetInMemorySegment<Integer>) statvfs::f_bfree, 0x01234567_89ABCDEFL, 0xFFFFFFFF),
+				Arguments.arguments(Named.of("setBavail(i) with i > UINT32", (SetInStatvfs<Long>) Statvfs::setBavail), (GetInMemorySegment<Integer>) statvfs::f_bavail, 0x01234567_89ABCDEFL, 0xFFFFFFFF)
 		);
 	}
 
diff --git a/jfuse-mac/src/test/java/org/cryptomator/jfuse/mac/TimeSpecImplTest.java b/jfuse-mac/src/test/java/org/cryptomator/jfuse/mac/TimeSpecImplTest.java
index 42b2be25..93b6e344 100644
--- a/jfuse-mac/src/test/java/org/cryptomator/jfuse/mac/TimeSpecImplTest.java
+++ b/jfuse-mac/src/test/java/org/cryptomator/jfuse/mac/TimeSpecImplTest.java
@@ -16,8 +16,8 @@ public class TimeSpecImplTest {
 	public void testGet() {
 		try (var arena = Arena.ofConfined()) {
 			var timeSpec = new TimeSpecImpl(timespec.allocate(arena));
-			timespec.tv_sec$set(timeSpec.segment(), 123L);
-			timespec.tv_nsec$set(timeSpec.segment(), 456L);
+			timespec.tv_sec(timeSpec.segment(), 123L);
+			timespec.tv_nsec(timeSpec.segment(), 456L);
 
 			var result = timeSpec.get();
 
@@ -31,13 +31,13 @@ public void testGet() {
 	public void testSet() {
 		try (var arena = Arena.ofConfined()) {
 			var timeSpec = new TimeSpecImpl(timespec.allocate(arena));
-			timespec.tv_sec$set(timeSpec.segment(), 0L);
-			timespec.tv_nsec$set(timeSpec.segment(), 0L);
+			timespec.tv_sec(timeSpec.segment(), 0L);
+			timespec.tv_nsec(timeSpec.segment(), 0L);
 
 			timeSpec.set(Instant.ofEpochSecond(123L, 456L));
 
-			Assertions.assertEquals(123L, timespec.tv_sec$get(timeSpec.segment()));
-			Assertions.assertEquals(456L, timespec.tv_nsec$get(timeSpec.segment()));
+			Assertions.assertEquals(123L, timespec.tv_sec(timeSpec.segment()));
+			Assertions.assertEquals(456L, timespec.tv_nsec(timeSpec.segment()));
 		}
 	}
 
@@ -46,8 +46,8 @@ public void testSet() {
 	public void testIsUtimeOmit() {
 		try (var arena = Arena.ofConfined()) {
 			var timeSpec = new TimeSpecImpl(timespec.allocate(arena));
-			timespec.tv_sec$set(timeSpec.segment(), 123L);
-			timespec.tv_nsec$set(timeSpec.segment(), stat_h.UTIME_OMIT());
+			timespec.tv_sec(timeSpec.segment(), 123L);
+			timespec.tv_nsec(timeSpec.segment(), stat_h.UTIME_OMIT());
 
 			Assertions.assertTrue(timeSpec.isUtimeOmit());
 			Assertions.assertFalse(timeSpec.isUtimeNow());
@@ -59,8 +59,8 @@ public void testIsUtimeOmit() {
 	public void testIsUtimeNow() {
 		try (var arena = Arena.ofConfined()) {
 			var timeSpec = new TimeSpecImpl(timespec.allocate(arena));
-			timespec.tv_sec$set(timeSpec.segment(), 123L);
-			timespec.tv_nsec$set(timeSpec.segment(), stat_h.UTIME_NOW());
+			timespec.tv_sec(timeSpec.segment(), 123L);
+			timespec.tv_nsec(timeSpec.segment(), stat_h.UTIME_NOW());
 
 			Assertions.assertFalse(timeSpec.isUtimeOmit());
 			Assertions.assertTrue(timeSpec.isUtimeNow());
diff --git a/jfuse-tests/pom.xml b/jfuse-tests/pom.xml
index cb4656c5..7f625f8d 100644
--- a/jfuse-tests/pom.xml
+++ b/jfuse-tests/pom.xml
@@ -81,7 +81,7 @@
 				<groupId>org.apache.maven.plugins</groupId>
 				<artifactId>maven-surefire-plugin</artifactId>
 				<configuration>
-					<argLine>@{surefire.jacoco.args} --enable-native-access=ALL-UNNAMED --enable-preview -Djava.library.path=".:${java.library.path}"</argLine>
+					<argLine>@{surefire.jacoco.args} --enable-native-access=ALL-UNNAMED -Djava.library.path=".:${java.library.path}"</argLine>
 					<systemPropertyVariables>
 						<fuse.lib.path>${fuse.lib.path}</fuse.lib.path>
 					</systemPropertyVariables>
@@ -100,7 +100,7 @@
 							<includes>
 								<include>**/*IT.java</include>
 							</includes>
-							<argLine>@{failsafe.jacoco.args} --enable-native-access=ALL-UNNAMED --enable-preview -Djava.library.path=".:${java.library.path}"</argLine>
+							<argLine>@{failsafe.jacoco.args} --enable-native-access=ALL-UNNAMED -Djava.library.path=".:${java.library.path}"</argLine>
 							<systemPropertyVariables>
 								<fuse.lib.path>${fuse.lib.path}</fuse.lib.path>
 							</systemPropertyVariables>
diff --git a/jfuse-win/pom.xml b/jfuse-win/pom.xml
index 326717bb..28abc7c5 100644
--- a/jfuse-win/pom.xml
+++ b/jfuse-win/pom.xml
@@ -15,7 +15,7 @@
 
 	<properties>
 		<win.ucrtHeaderPath>C:\Program Files (x86)\Windows Kits\10\Include\10.0.22621.0\ucrt</win.ucrtHeaderPath>
-		<jextract.executable>C:\Users\Arbeit\Skymatic\jextract\build\jextract\bin\jextract.bat</jextract.executable>
+		<jextract.executable>C:\Users\Arbeit\Programs\jextract-22\bin\jextract.bat</jextract.executable>
 	</properties>
 
 	<dependencies>
@@ -32,7 +32,7 @@
 				<groupId>org.apache.maven.plugins</groupId>
 				<artifactId>maven-surefire-plugin</artifactId>
 				<configuration>
-					<argLine>@{surefire.jacoco.args} -javaagent:${net.bytebuddy:byte-buddy-agent:jar} --enable-preview --enable-native-access=org.cryptomator.jfuse.win</argLine>
+					<argLine>@{surefire.jacoco.args} -javaagent:${net.bytebuddy:byte-buddy-agent:jar} --enable-native-access=org.cryptomator.jfuse.win</argLine>
 				</configuration>
 			</plugin>
 		</plugins>
@@ -83,7 +83,7 @@
 					<plugin>
 						<groupId>io.github.coffeelibs</groupId>
 						<artifactId>jextract-maven-plugin</artifactId>
-						<version>0.3.0</version>
+						<version>0.4.0</version>
 						<configuration>
 							<executable>${jextract.executable}</executable>
 							<headerSearchPaths>${win.ucrtHeaderPath}</headerSearchPaths>
diff --git a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/DirFillerImpl.java b/jfuse-win/src/main/java/org/cryptomator/jfuse/win/DirFillerImpl.java
index e20ee4d3..0c8c0180 100644
--- a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/DirFillerImpl.java
+++ b/jfuse-win/src/main/java/org/cryptomator/jfuse/win/DirFillerImpl.java
@@ -9,17 +9,13 @@
 import java.lang.foreign.MemorySegment;
 import java.util.function.Consumer;
 
-record DirFillerImpl(MemorySegment buf, fuse3_fill_dir_t callback, Arena arena) implements DirFiller {
-
-	DirFillerImpl(MemorySegment buf, MemorySegment callback, Arena arena) {
-		this(buf, fuse3_fill_dir_t.ofAddress(callback, arena), arena);
-	}
+record DirFillerImpl(MemorySegment buf, MemorySegment callback, Arena arena) implements DirFiller {
 
 	@Override
 	public int fill(String name, Consumer<Stat> statFiller, long offset, int flags) {
 		var statSegment = fuse_stat.allocate(arena);
 		statFiller.accept(new StatImpl(statSegment));
-		return callback.apply(buf, arena.allocateUtf8String(name), statSegment, offset, flags);
+		return fuse3_fill_dir_t.invoke(callback, buf, arena.allocateFrom(name), statSegment, offset, flags);
 	}
 
 }
\ No newline at end of file
diff --git a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/FileInfoImpl.java b/jfuse-win/src/main/java/org/cryptomator/jfuse/win/FileInfoImpl.java
index dd9f18bf..2133ca5f 100644
--- a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/FileInfoImpl.java
+++ b/jfuse-win/src/main/java/org/cryptomator/jfuse/win/FileInfoImpl.java
@@ -22,34 +22,28 @@ record FileInfoImpl(MemorySegment segment) implements FileInfo {
 	private static final int O_EXCL = fcntl_h.O_EXCL();
 
 	/**
-	 * Factory method to map native memory to an {@link FileInfo} object
+	 * Null-safe factory method to map native memory to an {@link FileInfo} object
 	 *
 	 * @param address the {@link MemorySegment} representing the starting address
-	 * @param scope   the {@link Arena} in which this object will be alive
 	 * @return an {@link FileInfo} object or {@code null} if {@code address} is a NULL pointer
 	 */
 	@Nullable
-	public static FileInfoImpl of(MemorySegment address, Arena scope) {
-		return MemorySegment.NULL.equals(address) ? null : new FileInfoImpl(address, scope);
+	public static FileInfoImpl ofNullable(MemorySegment address) {
+		return MemorySegment.NULL.equals(address) ? null : new FileInfoImpl(address);
 	}
-
-	public FileInfoImpl(MemorySegment address, Arena scope) {
-		this(fuse3_file_info.ofAddress(address, scope));
-	}
-
 	@Override
 	public long getFh() {
-		return fuse3_file_info.fh$get(segment);
+		return fuse3_file_info.fh(segment);
 	}
 
 	@Override
 	public void setFh(long fh) {
-		fuse3_file_info.fh$set(segment, fh);
+		fuse3_file_info.fh(segment, fh);
 	}
 
 	@Override
 	public int getFlags() {
-		return fuse3_file_info.flags$get(segment);
+		return fuse3_file_info.flags(segment);
 	}
 
 	@Override
@@ -84,7 +78,7 @@ public Set<StandardOpenOption> getOpenFlags() {
 
 	@Override
 	public long getLockOwner() {
-		return fuse3_file_info.lock_owner$get(segment);
+		return fuse3_file_info.lock_owner(segment);
 	}
 
 }
diff --git a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/FuseArgs.java b/jfuse-win/src/main/java/org/cryptomator/jfuse/win/FuseArgs.java
index dd639006..1717677e 100644
--- a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/FuseArgs.java
+++ b/jfuse-win/src/main/java/org/cryptomator/jfuse/win/FuseArgs.java
@@ -11,13 +11,13 @@ record FuseArgs(MemorySegment args, MemorySegment mountPoint, boolean multiThrea
 	@Override
 	public String toString() {
 		var sb = new StringBuilder();
-		var argc = fuse_args.argc$get(args);
-		var argv = fuse_args.argv$get(args);
+		var argc = fuse_args.argc(args);
+		var argv = fuse_args.argv(args);
 		for (int i = 0; i < argc; i++) {
 			var cString = argv.getAtIndex(ValueLayout.ADDRESS, i).reinterpret(Long.MAX_VALUE);
-			sb.append("arg[").append(i).append("] = ").append(cString.getUtf8String(0)).append(", ");
+			sb.append("arg[").append(i).append("] = ").append(cString.getString(0)).append(", ");
 		}
-		sb.append("mountPoint = ").append(mountPoint().reinterpret(Long.MAX_VALUE).getUtf8String(0)).append(", ");
+		sb.append("mountPoint = ").append(mountPoint().reinterpret(Long.MAX_VALUE).getString(0)).append(", ");
 		sb.append("singlethreaded = ").append(!multiThreaded);
 		return sb.toString();
 	}
diff --git a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/FuseConfigImpl.java b/jfuse-win/src/main/java/org/cryptomator/jfuse/win/FuseConfigImpl.java
index 7c4889f9..afc3eedb 100644
--- a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/FuseConfigImpl.java
+++ b/jfuse-win/src/main/java/org/cryptomator/jfuse/win/FuseConfigImpl.java
@@ -8,113 +8,109 @@
 
 record FuseConfigImpl(MemorySegment segment) implements FuseConfig {
 
-	public FuseConfigImpl(MemorySegment address, Arena scope) {
-		this(fuse3_config.ofAddress(address, scope));
-	}
-
 	@Override
 	public int setGid() {
-		return fuse3_config.set_gid$get(segment);
+		return fuse3_config.set_gid(segment);
 	}
 
 	@Override
 	public int gid() {
-		return fuse3_config.gid$get(segment);
+		return fuse3_config.gid(segment);
 	}
 
 	@Override
 	public int setUid() {
-		return fuse3_config.set_uid$get(segment);
+		return fuse3_config.set_uid(segment);
 	}
 
 	@Override
 	public int uid() {
-		return fuse3_config.uid$get(segment);
+		return fuse3_config.uid(segment);
 	}
 
 	@Override
 	public int setMode() {
-		return fuse3_config.set_mode$get(segment);
+		return fuse3_config.set_mode(segment);
 	}
 
 	@Override
 	public int umask() {
-		return fuse3_config.umask$get(segment);
+		return fuse3_config.umask(segment);
 	}
 
 	@Override
 	public double entryTimeout() {
-		return fuse3_config.entry_timeout$get(segment);
+		return fuse3_config.entry_timeout(segment);
 	}
 
 	@Override
 	public double negativeTimeout() {
-		return fuse3_config.negative_timeout$get(segment);
+		return fuse3_config.negative_timeout(segment);
 	}
 
 	@Override
 	public double attrTimeout() {
-		return fuse3_config.attr_timeout$get(segment);
+		return fuse3_config.attr_timeout(segment);
 	}
 
 	@Override
 	public int intr() {
-		return fuse3_config.intr$get(segment);
+		return fuse3_config.intr(segment);
 	}
 
 	@Override
 	public int intrSignal() {
-		return fuse3_config.intr_signal$get(segment);
+		return fuse3_config.intr_signal(segment);
 	}
 
 	@Override
 	public int remember() {
-		return fuse3_config.remember$get(segment);
+		return fuse3_config.remember(segment);
 	}
 
 	@Override
 	public int hardRemove() {
-		return fuse3_config.hard_remove$get(segment);
+		return fuse3_config.hard_remove(segment);
 	}
 
 	@Override
 	public int useIno() {
-		return fuse3_config.use_ino$get(segment);
+		return fuse3_config.use_ino(segment);
 	}
 
 	@Override
 	public int readdirIno() {
-		return fuse3_config.readdir_ino$get(segment);
+		return fuse3_config.readdir_ino(segment);
 	}
 
 	@Override
 	public int directIo() {
-		return fuse3_config.direct_io$get(segment);
+		return fuse3_config.direct_io(segment);
 	}
 
 	@Override
 	public int kernelCache() {
-		return fuse3_config.kernel_cache$get(segment);
+		return fuse3_config.kernel_cache(segment);
 	}
 
 	@Override
 	public int autoCache() {
-		return fuse3_config.auto_cache$get(segment);
+		return fuse3_config.auto_cache(segment);
 	}
 
 	@Override
 	public int acAttrTimeoutSet() {
-		return fuse3_config.ac_attr_timeout_set$get(segment);
+		return fuse3_config.ac_attr_timeout_set(segment);
 	}
 
 	@Override
 	public double acAttrTimeout() {
-		return fuse3_config.ac_attr_timeout$get(segment);
+		return fuse3_config.ac_attr_timeout(segment);
 	}
 
 	@Override
 	public int nullpathOk() {
-		return fuse3_config.nullpath_ok$get(segment);
+		return fuse3_config.nullpath_ok(segment);
 	}
 
 	@Override
diff --git a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/FuseConnInfoImpl.java b/jfuse-win/src/main/java/org/cryptomator/jfuse/win/FuseConnInfoImpl.java
index 8893f719..a557d6ea 100644
--- a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/FuseConnInfoImpl.java
+++ b/jfuse-win/src/main/java/org/cryptomator/jfuse/win/FuseConnInfoImpl.java
@@ -8,93 +8,89 @@
 
 record FuseConnInfoImpl(MemorySegment segment) implements FuseConnInfo {
 
-	public FuseConnInfoImpl(MemorySegment address, Arena scope) {
-		this(fuse3_conn_info.ofAddress(address, scope));
-	}
-
 	@Override
 	public int protoMajor() {
-		return fuse3_conn_info.proto_major$get(segment);
+		return fuse3_conn_info.proto_major(segment);
 	}
 
 	@Override
 	public int protoMinor() {
-		return fuse3_conn_info.proto_minor$get(segment);
+		return fuse3_conn_info.proto_minor(segment);
 	}
 
 	@Override
 	public int capable() {
-		return fuse3_conn_info.capable$get(segment);
+		return fuse3_conn_info.capable(segment);
 	}
 
 	@Override
 	public int want() {
-		return fuse3_conn_info.want$get(segment);
+		return fuse3_conn_info.want(segment);
 	}
 
 	@Override
 	public void setWant(int wanted) {
-		fuse3_conn_info.want$set(segment, wanted);
+		fuse3_conn_info.want(segment, wanted);
 	}
 
 	@Override
 	public int maxWrite() {
-		return fuse3_conn_info.max_write$get(segment);
+		return fuse3_conn_info.max_write(segment);
 	}
 
 	@Override
 	public void setMaxWrite(int maxWrite) {
-		fuse3_conn_info.max_write$set(segment, maxWrite);
+		fuse3_conn_info.max_write(segment, maxWrite);
 	}
 
 	@Override
 	public int maxRead() {
-		return fuse3_conn_info.max_read$get(segment);
+		return fuse3_conn_info.max_read(segment);
 	}
 
 	@Override
 	public void setMaxRead(int maxRead) {
-		fuse3_conn_info.max_read$set(segment, maxRead);
+		fuse3_conn_info.max_read(segment, maxRead);
 	}
 
 	@Override
 	public int maxReadahead() {
-		return fuse3_conn_info.max_readahead$get(segment);
+		return fuse3_conn_info.max_readahead(segment);
 	}
 
 	@Override
 	public void setMaxReadahead(int maxReadahead) {
-		fuse3_conn_info.max_readahead$set(segment, maxReadahead);
+		fuse3_conn_info.max_readahead(segment, maxReadahead);
 	}
 
 	@Override
 	public int maxBackground() {
-		return fuse3_conn_info.max_background$get(segment);
+		return fuse3_conn_info.max_background(segment);
 	}
 
 	@Override
 	public void setMaxBackground(int maxBackground) {
-		fuse3_conn_info.max_background$set(segment, maxBackground);
+		fuse3_conn_info.max_background(segment, maxBackground);
 	}
 
 	@Override
 	public int congestionThreshold() {
-		return fuse3_conn_info.congestion_threshold$get(segment);
+		return fuse3_conn_info.congestion_threshold(segment);
 	}
 
 	@Override
 	public void setCongestionThreshold(int congestionThreshold) {
-		fuse3_conn_info.congestion_threshold$set(segment, congestionThreshold);
+		fuse3_conn_info.congestion_threshold(segment, congestionThreshold);
 	}
 
 	@Override
 	public int timeGran() {
-		return fuse3_conn_info.time_gran$get(segment);
+		return fuse3_conn_info.time_gran(segment);
 	}
 
 	@Override
 	public void setTimeGran(int timeGran) {
-		fuse3_conn_info.time_gran$set(segment, timeGran);
+		fuse3_conn_info.time_gran(segment, timeGran);
 	}
 
 }
diff --git a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/FuseImpl.java b/jfuse-win/src/main/java/org/cryptomator/jfuse/win/FuseImpl.java
index 3a6f59b0..e85e93ad 100644
--- a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/FuseImpl.java
+++ b/jfuse-win/src/main/java/org/cryptomator/jfuse/win/FuseImpl.java
@@ -55,15 +55,15 @@ protected FuseMount mount(List<String> args) throws FuseMountFailedException {
 	FuseArgs parseArgs(List<String> cmdLineArgs) throws IllegalArgumentException {
 		var args = fuse_args.allocate(fuseArena);
 		var argc = cmdLineArgs.size();
-		var argv = fuseArena.allocateArray(ValueLayout.ADDRESS, argc + 1L);
+		var argv = fuseArena.allocate(ValueLayout.ADDRESS, argc + 1L);
 		for (int i = 0; i < argc; i++) {
-			var cString = fuseArena.allocateUtf8String(cmdLineArgs.get(i));
+			var cString = fuseArena.allocateFrom(cmdLineArgs.get(i));
 			argv.setAtIndex(ValueLayout.ADDRESS, i, cString);
 		}
 		argv.setAtIndex(ValueLayout.ADDRESS, argc, MemorySegment.NULL);
-		fuse_args.argc$set(args, argc);
-		fuse_args.argv$set(args, argv);
-		fuse_args.allocated$set(args, 0);
+		fuse_args.argc(args, argc);
+		fuse_args.argv(args, argv);
+		fuse_args.allocated(args, 0);
 
 		var multithreaded = fuseArena.allocate(JAVA_INT, 1);
 		var foreground = fuseArena.allocate(JAVA_INT, 1);
@@ -80,67 +80,59 @@ FuseArgs parseArgs(List<String> cmdLineArgs) throws IllegalArgumentException {
 	@Override
 	protected void bind(FuseOperations.Operation operation) {
 		switch (operation) {
-			case INIT -> fuse3_operations.init$set(fuseOperationsStruct, fuse3_operations.init.allocate(this::init, fuseArena));
-			case ACCESS -> fuse3_operations.access$set(fuseOperationsStruct, MemorySegment.NULL);
-			case CHMOD -> fuse3_operations.chmod$set(fuseOperationsStruct, fuse3_operations.chmod.allocate(this::chmod, fuseArena));
-			case CHOWN -> fuse3_operations.chown$set(fuseOperationsStruct, fuse3_operations.chown.allocate(this::chown, fuseArena));
-			case CREATE -> fuse3_operations.create$set(fuseOperationsStruct, fuse3_operations.create.allocate(this::create, fuseArena));
-			case DESTROY -> fuse3_operations.destroy$set(fuseOperationsStruct, fuse3_operations.destroy.allocate(this::destroy, fuseArena));
-			case FLUSH -> fuse3_operations.flush$set(fuseOperationsStruct, fuse3_operations.flush.allocate(this::flush, fuseArena));
-			case FSYNC -> fuse3_operations.fsync$set(fuseOperationsStruct, fuse3_operations.fsync.allocate(this::fsync, fuseArena));
-			case FSYNCDIR -> fuse3_operations.fsyncdir$set(fuseOperationsStruct, fuse3_operations.fsyncdir.allocate(this::fsyncdir, fuseArena));
-			case GET_ATTR -> fuse3_operations.getattr$set(fuseOperationsStruct, fuse3_operations.getattr.allocate(this::getattr, fuseArena));
-			case GET_XATTR -> fuse3_operations.getxattr$set(fuseOperationsStruct, fuse3_operations.getxattr.allocate(this::getxattr, fuseArena));
-			case LIST_XATTR -> fuse3_operations.listxattr$set(fuseOperationsStruct, fuse3_operations.listxattr.allocate(this::listxattr, fuseArena));
-			case MKDIR -> fuse3_operations.mkdir$set(fuseOperationsStruct, fuse3_operations.mkdir.allocate(this::mkdir, fuseArena));
-			case OPEN -> fuse3_operations.open$set(fuseOperationsStruct, fuse3_operations.open.allocate(this::open, fuseArena));
-			case OPEN_DIR -> fuse3_operations.opendir$set(fuseOperationsStruct, fuse3_operations.opendir.allocate(this::opendir, fuseArena));
-			case READ -> fuse3_operations.read$set(fuseOperationsStruct, fuse3_operations.read.allocate(this::read, fuseArena));
-			case READ_DIR -> fuse3_operations.readdir$set(fuseOperationsStruct, fuse3_operations.readdir.allocate(this::readdir, fuseArena));
-			case READLINK -> fuse3_operations.readlink$set(fuseOperationsStruct, fuse3_operations.readlink.allocate(this::readlink, fuseArena));
-			case RELEASE -> fuse3_operations.release$set(fuseOperationsStruct, fuse3_operations.release.allocate(this::release, fuseArena));
-			case RELEASE_DIR -> fuse3_operations.releasedir$set(fuseOperationsStruct, fuse3_operations.releasedir.allocate(this::releasedir, fuseArena));
-			case REMOVE_XATTR -> fuse3_operations.removexattr$set(fuseOperationsStruct, fuse3_operations.removexattr.allocate(this::removexattr, fuseArena));
-			case RENAME -> fuse3_operations.rename$set(fuseOperationsStruct, fuse3_operations.rename.allocate(this::rename, fuseArena));
-			case RMDIR -> fuse3_operations.rmdir$set(fuseOperationsStruct, fuse3_operations.rmdir.allocate(this::rmdir, fuseArena));
-			case SET_XATTR -> fuse3_operations.setxattr$set(fuseOperationsStruct, fuse3_operations.setxattr.allocate(this::setxattr, fuseArena));
-			case STATFS -> fuse3_operations.statfs$set(fuseOperationsStruct, fuse3_operations.statfs.allocate(this::statfs, fuseArena));
-			case SYMLINK -> fuse3_operations.symlink$set(fuseOperationsStruct, fuse3_operations.symlink.allocate(this::symlink, fuseArena));
-			case TRUNCATE -> fuse3_operations.truncate$set(fuseOperationsStruct, fuse3_operations.truncate.allocate(this::truncate, fuseArena));
-			case UNLINK -> fuse3_operations.unlink$set(fuseOperationsStruct, fuse3_operations.unlink.allocate(this::unlink, fuseArena));
-			case UTIMENS -> fuse3_operations.utimens$set(fuseOperationsStruct, fuse3_operations.utimens.allocate(this::utimens, fuseArena));
-			case WRITE -> fuse3_operations.write$set(fuseOperationsStruct, fuse3_operations.write.allocate(this::write, fuseArena));
+			case INIT -> fuse3_operations.init(fuseOperationsStruct, fuse3_operations.init.allocate(this::init, fuseArena));
+			case ACCESS -> fuse3_operations.access(fuseOperationsStruct, MemorySegment.NULL);
+			case CHMOD -> fuse3_operations.chmod(fuseOperationsStruct, fuse3_operations.chmod.allocate(this::chmod, fuseArena));
+			case CHOWN -> fuse3_operations.chown(fuseOperationsStruct, fuse3_operations.chown.allocate(this::chown, fuseArena));
+			case CREATE -> fuse3_operations.create(fuseOperationsStruct, fuse3_operations.create.allocate(this::create, fuseArena));
+			case DESTROY -> fuse3_operations.destroy(fuseOperationsStruct, fuse3_operations.destroy.allocate(this::destroy, fuseArena));
+			case FLUSH -> fuse3_operations.flush(fuseOperationsStruct, fuse3_operations.flush.allocate(this::flush, fuseArena));
+			case FSYNC -> fuse3_operations.fsync(fuseOperationsStruct, fuse3_operations.fsync.allocate(this::fsync, fuseArena));
+			case FSYNCDIR -> fuse3_operations.fsyncdir(fuseOperationsStruct, fuse3_operations.fsyncdir.allocate(this::fsyncdir, fuseArena));
+			case GET_ATTR -> fuse3_operations.getattr(fuseOperationsStruct, fuse3_operations.getattr.allocate(this::getattr, fuseArena));
+			case GET_XATTR -> fuse3_operations.getxattr(fuseOperationsStruct, fuse3_operations.getxattr.allocate(this::getxattr, fuseArena));
+			case LIST_XATTR -> fuse3_operations.listxattr(fuseOperationsStruct, fuse3_operations.listxattr.allocate(this::listxattr, fuseArena));
+			case MKDIR -> fuse3_operations.mkdir(fuseOperationsStruct, fuse3_operations.mkdir.allocate(this::mkdir, fuseArena));
+			case OPEN -> fuse3_operations.open(fuseOperationsStruct, fuse3_operations.open.allocate(this::open, fuseArena));
+			case OPEN_DIR -> fuse3_operations.opendir(fuseOperationsStruct, fuse3_operations.opendir.allocate(this::opendir, fuseArena));
+			case READ -> fuse3_operations.read(fuseOperationsStruct, fuse3_operations.read.allocate(this::read, fuseArena));
+			case READ_DIR -> fuse3_operations.readdir(fuseOperationsStruct, fuse3_operations.readdir.allocate(this::readdir, fuseArena));
+			case READLINK -> fuse3_operations.readlink(fuseOperationsStruct, fuse3_operations.readlink.allocate(this::readlink, fuseArena));
+			case RELEASE -> fuse3_operations.release(fuseOperationsStruct, fuse3_operations.release.allocate(this::release, fuseArena));
+			case RELEASE_DIR -> fuse3_operations.releasedir(fuseOperationsStruct, fuse3_operations.releasedir.allocate(this::releasedir, fuseArena));
+			case REMOVE_XATTR -> fuse3_operations.removexattr(fuseOperationsStruct, fuse3_operations.removexattr.allocate(this::removexattr, fuseArena));
+			case RENAME -> fuse3_operations.rename(fuseOperationsStruct, fuse3_operations.rename.allocate(this::rename, fuseArena));
+			case RMDIR -> fuse3_operations.rmdir(fuseOperationsStruct, fuse3_operations.rmdir.allocate(this::rmdir, fuseArena));
+			case SET_XATTR -> fuse3_operations.setxattr(fuseOperationsStruct, fuse3_operations.setxattr.allocate(this::setxattr, fuseArena));
+			case STATFS -> fuse3_operations.statfs(fuseOperationsStruct, fuse3_operations.statfs.allocate(this::statfs, fuseArena));
+			case SYMLINK -> fuse3_operations.symlink(fuseOperationsStruct, fuse3_operations.symlink.allocate(this::symlink, fuseArena));
+			case TRUNCATE -> fuse3_operations.truncate(fuseOperationsStruct, fuse3_operations.truncate.allocate(this::truncate, fuseArena));
+			case UNLINK -> fuse3_operations.unlink(fuseOperationsStruct, fuse3_operations.unlink.allocate(this::unlink, fuseArena));
+			case UTIMENS -> fuse3_operations.utimens(fuseOperationsStruct, fuse3_operations.utimens.allocate(this::utimens, fuseArena));
+			case WRITE -> fuse3_operations.write(fuseOperationsStruct, fuse3_operations.write.allocate(this::write, fuseArena));
 		}
 	}
 
 	@VisibleForTesting
 	MemorySegment init(MemorySegment conn, MemorySegment cfg) {
-		try (var arena = Arena.ofConfined()) {
-			var connInfo = new FuseConnInfoImpl(conn, arena);
-			connInfo.setWant(connInfo.want() | FuseConnInfo.FUSE_CAP_READDIRPLUS);
-			var config = new FuseConfigImpl(cfg, arena);
-			fuseOperations.init(connInfo, config);
-		}
+		var connInfo = new FuseConnInfoImpl(conn);
+		connInfo.setWant(connInfo.want() | FuseConnInfo.FUSE_CAP_READDIRPLUS);
+		var config = new FuseConfigImpl(cfg);
+		fuseOperations.init(connInfo, config);
 		return MemorySegment.NULL;
 	}
 
 	private int chmod(MemorySegment path, int mode, MemorySegment fi) {
-		try (var arena = Arena.ofConfined()) {
-			return fuseOperations.chmod(path.getUtf8String(0), mode, FileInfoImpl.of(fi, arena));
-		}
+		return fuseOperations.chmod(path.getString(0), mode, FileInfoImpl.ofNullable(fi));
 	}
 
 	@VisibleForTesting
 	int chown(MemorySegment path, int uid, int gid, MemorySegment fi) {
-		try (var arena = Arena.ofConfined()) {
-			return fuseOperations.chown(path.getUtf8String(0), uid, gid, FileInfoImpl.of(fi, arena));
-		}
+		return fuseOperations.chown(path.getString(0), uid, gid, FileInfoImpl.ofNullable(fi));
 	}
 
 	private int create(MemorySegment path, int mode, MemorySegment fi) {
-		try (var arena = Arena.ofConfined()) {
-			return fuseOperations.create(path.getUtf8String(0), mode, new FileInfoImpl(fi, arena));
-		}
+		return fuseOperations.create(path.getString(0), mode, new FileInfoImpl(fi));
 	}
 
 	private void destroy(MemorySegment addr) {
@@ -149,128 +141,106 @@ private void destroy(MemorySegment addr) {
 
 	@VisibleForTesting
 	int flush(MemorySegment path, MemorySegment fi) {
-		try (var arena = Arena.ofConfined()) {
-			return fuseOperations.flush(path.getUtf8String(0), new FileInfoImpl(fi, arena));
-		}
+		return fuseOperations.flush(path.getString(0), new FileInfoImpl(fi));
 	}
 
 	@VisibleForTesting
 	int fsync(MemorySegment path, int datasync, MemorySegment fi) {
-		try (var arena = Arena.ofConfined()) {
-			return fuseOperations.fsync(path.getUtf8String(0), datasync, new FileInfoImpl(fi, arena));
-		}
+		return fuseOperations.fsync(path.getString(0), datasync, new FileInfoImpl(fi));
 	}
 
 	@VisibleForTesting
 	int fsyncdir(MemorySegment path, int datasync, MemorySegment fi) {
-		try (var arena = Arena.ofConfined()) {
-			return fuseOperations.fsyncdir(MemoryUtils.toUtf8StringOrNull(path), datasync, new FileInfoImpl(fi, arena));
-		}
+		return fuseOperations.fsyncdir(MemoryUtils.toUtf8StringOrNull(path), datasync, new FileInfoImpl(fi));
 	}
 
 	@VisibleForTesting
 	int getattr(MemorySegment path, MemorySegment stat, MemorySegment fi) {
-		try (var arena = Arena.ofConfined()) {
-			return fuseOperations.getattr(path.getUtf8String(0), new StatImpl(stat, arena), FileInfoImpl.of(fi, arena));
-		}
+		return fuseOperations.getattr(path.getString(0), new StatImpl(stat), FileInfoImpl.ofNullable(fi));
 	}
 
 	@VisibleForTesting
 	int getxattr(MemorySegment path, MemorySegment name, MemorySegment value, long size) {
 		var val = value.reinterpret(size).asByteBuffer();
-		return fuseOperations.getxattr(path.getUtf8String(0), name.getUtf8String(0), val);
+		return fuseOperations.getxattr(path.getString(0), name.getString(0), val);
 	}
 
 	@VisibleForTesting
 	int setxattr(MemorySegment path, MemorySegment name, MemorySegment value, long size, int flags) {
 		var val = value.reinterpret(size).asByteBuffer();
-		return fuseOperations.setxattr(path.getUtf8String(0), name.getUtf8String(0), val, flags);
+		return fuseOperations.setxattr(path.getString(0), name.getString(0), val, flags);
 	}
 
 	@VisibleForTesting
 	int listxattr(MemorySegment path, MemorySegment value, long size) {
 		var val = value.reinterpret(size).asByteBuffer();
-		return fuseOperations.listxattr(path.getUtf8String(0), val);
+		return fuseOperations.listxattr(path.getString(0), val);
 	}
 
 	@VisibleForTesting
 	int removexattr(MemorySegment path, MemorySegment name) {
-		return fuseOperations.removexattr(path.getUtf8String(0), name.getUtf8String(0));
+		return fuseOperations.removexattr(path.getString(0), name.getString(0));
 	}
 
 	private int mkdir(MemorySegment path, int mode) {
-		return fuseOperations.mkdir(path.getUtf8String(0), mode);
+		return fuseOperations.mkdir(path.getString(0), mode);
 	}
 
 	private int open(MemorySegment path, MemorySegment fi) {
-		try (var arena = Arena.ofConfined()) {
-			return fuseOperations.open(path.getUtf8String(0), new FileInfoImpl(fi, arena));
-		}
+		return fuseOperations.open(path.getString(0), new FileInfoImpl(fi));
 	}
 
 	private int opendir(MemorySegment path, MemorySegment fi) {
-		try (var arena = Arena.ofConfined()) {
-			return fuseOperations.opendir(path.getUtf8String(0), new FileInfoImpl(fi, arena));
-		}
+		return fuseOperations.opendir(path.getString(0), new FileInfoImpl(fi));
 	}
 
 	private int read(MemorySegment path, MemorySegment buf, long size, long offset, MemorySegment fi) {
-		try (var arena = Arena.ofConfined()) {
-			var buffer = buf.reinterpret(size).asByteBuffer();
-			return fuseOperations.read(path.getUtf8String(0), buffer, size, offset, new FileInfoImpl(fi, arena));
-		}
+		var buffer = buf.reinterpret(size).asByteBuffer();
+		return fuseOperations.read(path.getString(0), buffer, size, offset, new FileInfoImpl(fi));
 	}
 
 	private int readdir(MemorySegment path, MemorySegment buf, MemorySegment filler, long offset, MemorySegment fi, int flags) {
 		try (var arena = Arena.ofConfined()) {
-			return fuseOperations.readdir(path.getUtf8String(0), new DirFillerImpl(buf, filler, arena), offset, new FileInfoImpl(fi, arena), flags);
+			return fuseOperations.readdir(path.getString(0), new DirFillerImpl(buf, filler, arena), offset, new FileInfoImpl(fi), flags);
 		}
 	}
 
 	private int readlink(MemorySegment path, MemorySegment buf, long len) {
 		var buffer = buf.reinterpret(len).asByteBuffer();
-		return fuseOperations.readlink(path.getUtf8String(0), buffer, len);
+		return fuseOperations.readlink(path.getString(0), buffer, len);
 	}
 
 	private int release(MemorySegment path, MemorySegment fi) {
-		try (var arena = Arena.ofConfined()) {
-			return fuseOperations.release(path.getUtf8String(0), new FileInfoImpl(fi, arena));
-		}
+		return fuseOperations.release(path.getString(0), new FileInfoImpl(fi));
 	}
 
 	private int releasedir(MemorySegment path, MemorySegment fi) {
-		try (var arena = Arena.ofConfined()) {
-			return fuseOperations.releasedir(MemoryUtils.toUtf8StringOrNull(path), new FileInfoImpl(fi, arena));
-		}
+		return fuseOperations.releasedir(MemoryUtils.toUtf8StringOrNull(path), new FileInfoImpl(fi));
 	}
 
 	private int rename(MemorySegment oldpath, MemorySegment newpath, int flags) {
-		return fuseOperations.rename(oldpath.getUtf8String(0), newpath.getUtf8String(0), flags);
+		return fuseOperations.rename(oldpath.getString(0), newpath.getString(0), flags);
 	}
 
 	private int rmdir(MemorySegment path) {
-		return fuseOperations.rmdir(path.getUtf8String(0));
+		return fuseOperations.rmdir(path.getString(0));
 	}
 
 	private int statfs(MemorySegment path, MemorySegment statvfs) {
-		try (var arena = Arena.ofConfined()) {
-			return fuseOperations.statfs(path.getUtf8String(0), new StatvfsImpl(statvfs, arena));
-		}
+		return fuseOperations.statfs(path.getString(0), new StatvfsImpl(statvfs));
 	}
 
 	private int symlink(MemorySegment linkname, MemorySegment target) {
-		return fuseOperations.symlink(linkname.getUtf8String(0), target.getUtf8String(0));
+		return fuseOperations.symlink(linkname.getString(0), target.getString(0));
 	}
 
 	@VisibleForTesting
 	int truncate(MemorySegment path, long size, MemorySegment fi) {
-		try (var arena = Arena.ofConfined()) {
-			return fuseOperations.truncate(path.getUtf8String(0), size, FileInfoImpl.of(fi, arena));
-		}
+		return fuseOperations.truncate(path.getString(0), size, FileInfoImpl.ofNullable(fi));
 	}
 
 	private int unlink(MemorySegment path) {
-		return fuseOperations.unlink(path.getUtf8String(0));
+		return fuseOperations.unlink(path.getString(0));
 	}
 
 	@VisibleForTesting
@@ -278,19 +248,15 @@ int utimens(MemorySegment path, MemorySegment times, MemorySegment fi) {
 		try (var arena = Arena.ofConfined()) {
 			// On Windows we know for sure that WinFSP will call this function only with
 			// valid times: https://github.com/winfsp/winfsp/discussions/445
-			var seq = MemoryLayout.sequenceLayout(2, fuse_timespec.$LAYOUT());
-			var segment = times.reinterpret(seq.byteSize());
-			var time0 = segment.asSlice(0, fuse_timespec.$LAYOUT().byteSize());
-			var time1 = segment.asSlice(fuse_timespec.$LAYOUT().byteSize(), fuse_timespec.$LAYOUT().byteSize());
-			return fuseOperations.utimens(path.getUtf8String(0), new TimeSpecImpl(time0), new TimeSpecImpl(time1), FileInfoImpl.of(fi, arena));
+			var time0 = fuse_timespec.asSlice(times, 0);
+			var time1 = fuse_timespec.asSlice(times, 1);
+			return fuseOperations.utimens(path.getString(0), new TimeSpecImpl(time0), new TimeSpecImpl(time1), FileInfoImpl.ofNullable(fi));
 		}
 	}
 
 	private int write(MemorySegment path, MemorySegment buf, long size, long offset, MemorySegment fi) {
-		try (var arena = Arena.ofConfined()) {
-			var buffer = buf.reinterpret(size).asByteBuffer();
-			return fuseOperations.write(path.getUtf8String(0), buffer, size, offset, new FileInfoImpl(fi, arena));
-		}
+		var buffer = buf.reinterpret(size).asByteBuffer();
+		return fuseOperations.write(path.getString(0), buffer, size, offset, new FileInfoImpl(fi));
 	}
 
 }
diff --git a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/StatImpl.java b/jfuse-win/src/main/java/org/cryptomator/jfuse/win/StatImpl.java
index d55b2a79..9ce368ea 100644
--- a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/StatImpl.java
+++ b/jfuse-win/src/main/java/org/cryptomator/jfuse/win/StatImpl.java
@@ -9,78 +9,74 @@
 
 record StatImpl(MemorySegment segment) implements Stat {
 
-	public StatImpl(MemorySegment address, Arena scope) {
-		this(fuse_stat.ofAddress(address, scope));
-	}
-
 	@Override
 	public TimeSpec aTime() {
-		return new TimeSpecImpl(fuse_stat.st_atim$slice(segment));
+		return new TimeSpecImpl(fuse_stat.st_atim(segment));
 	}
 
 	@Override
 	public TimeSpec cTime() {
-		return new TimeSpecImpl(fuse_stat.st_ctim$slice(segment));
+		return new TimeSpecImpl(fuse_stat.st_ctim(segment));
 	}
 
 	@Override
 	public TimeSpec mTime() {
-		return new TimeSpecImpl(fuse_stat.st_mtim$slice(segment));
+		return new TimeSpecImpl(fuse_stat.st_mtim(segment));
 	}
 
 	@Override
 	public TimeSpec birthTime() {
-		return new TimeSpecImpl(fuse_stat.st_birthtim$slice(segment));
+		return new TimeSpecImpl(fuse_stat.st_birthtim(segment));
 	}
 
 	@Override
 	public void setMode(int mode) {
-		fuse_stat.st_mode$set(segment, mode);
+		fuse_stat.st_mode(segment, mode);
 	}
 
 	@Override
 	public int getMode() {
-		return fuse_stat.st_mode$get(segment);
+		return fuse_stat.st_mode(segment);
 	}
 
 	@Override
 	public void setUid(int uid) {
-		fuse_stat.st_uid$set(segment, uid);
+		fuse_stat.st_uid(segment, uid);
 	}
 
 	@Override
 	public int getUid() {
-		return fuse_stat.st_uid$get(segment);
+		return fuse_stat.st_uid(segment);
 	}
 
 	@Override
 	public void setGid(int gid) {
-		fuse_stat.st_gid$set(segment, gid);
+		fuse_stat.st_gid(segment, gid);
 	}
 
 	@Override
 	public int getGid() {
-		return fuse_stat.st_gid$get(segment);
+		return fuse_stat.st_gid(segment);
 	}
 
 	@Override
 	public void setNLink(short count) {
-		fuse_stat.st_nlink$set(segment, count);
+		fuse_stat.st_nlink(segment, count);
 	}
 
 	@Override
 	public long getNLink() {
-		return fuse_stat.st_nlink$get(segment);
+		return fuse_stat.st_nlink(segment);
 	}
 
 	@Override
 	public void setSize(long size) {
-		fuse_stat.st_size$set(segment, size);
+		fuse_stat.st_size(segment, size);
 	}
 
 	@Override
 	public long getSize() {
-		return fuse_stat.st_size$get(segment);
+		return fuse_stat.st_size(segment);
 	}
 
 }
diff --git a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/StatvfsImpl.java b/jfuse-win/src/main/java/org/cryptomator/jfuse/win/StatvfsImpl.java
index 40c4d129..e7e39be7 100644
--- a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/StatvfsImpl.java
+++ b/jfuse-win/src/main/java/org/cryptomator/jfuse/win/StatvfsImpl.java
@@ -8,68 +8,64 @@
 
 record StatvfsImpl(MemorySegment segment) implements Statvfs {
 
-	public StatvfsImpl(MemorySegment address, Arena scope) {
-		this(fuse_statvfs.ofAddress(address, scope));
-	}
-
 	@Override
 	public long getBsize() {
-		return fuse_statvfs.f_bsize$get(segment);
+		return fuse_statvfs.f_bsize(segment);
 	}
 
 	@Override
 	public void setBsize(long bsize) {
-		fuse_statvfs.f_bsize$set(segment, bsize);
+		fuse_statvfs.f_bsize(segment, bsize);
 	}
 
 	@Override
 	public long getFrsize() {
-		return fuse_statvfs.f_frsize$get(segment);
+		return fuse_statvfs.f_frsize(segment);
 	}
 
 	@Override
 	public void setFrsize(long frsize) {
-		fuse_statvfs.f_frsize$set(segment, frsize);
+		fuse_statvfs.f_frsize(segment, frsize);
 	}
 
 	@Override
 	public long getBlocks() {
-		return fuse_statvfs.f_blocks$get(segment);
+		return fuse_statvfs.f_blocks(segment);
 	}
 
 	@Override
 	public void setBlocks(long blocks) {
-		fuse_statvfs.f_blocks$set(segment, blocks);
+		fuse_statvfs.f_blocks(segment, blocks);
 	}
 
 	@Override
 	public long getBfree() {
-		return fuse_statvfs.f_bfree$get(segment);
+		return fuse_statvfs.f_bfree(segment);
 	}
 
 	@Override
 	public void setBfree(long bfree) {
-		fuse_statvfs.f_bfree$set(segment, bfree);
+		fuse_statvfs.f_bfree(segment, bfree);
 	}
 
 	@Override
 	public long getBavail() {
-		return fuse_statvfs.f_bavail$get(segment);
+		return fuse_statvfs.f_bavail(segment);
 	}
 
 	@Override
 	public void setBavail(long bavail) {
-		fuse_statvfs.f_bavail$set(segment, bavail);
+		fuse_statvfs.f_bavail(segment, bavail);
 	}
 
 	@Override
 	public long getNameMax() {
-		return fuse_statvfs.f_namemax$get(segment);
+		return fuse_statvfs.f_namemax(segment);
 	}
 
 	@Override
 	public void setNameMax(long namemax) {
-		fuse_statvfs.f_namemax$set(segment, namemax);
+		fuse_statvfs.f_namemax(segment, namemax);
 	}
 
 }
diff --git a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/TimeSpecImpl.java b/jfuse-win/src/main/java/org/cryptomator/jfuse/win/TimeSpecImpl.java
index be25a16a..3b0336b1 100644
--- a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/TimeSpecImpl.java
+++ b/jfuse-win/src/main/java/org/cryptomator/jfuse/win/TimeSpecImpl.java
@@ -22,14 +22,14 @@ public boolean isUtimeNow() {
 
 	@Override
 	public void set(Instant newValue) {
-		fuse_timespec.tv_sec$set(segment, newValue.getEpochSecond());
-		fuse_timespec.tv_nsec$set(segment, newValue.getNano());
+		fuse_timespec.tv_sec(segment, newValue.getEpochSecond());
+		fuse_timespec.tv_nsec(segment, newValue.getNano());
 	}
 
 	@Override
 	public Instant get() {
-		var seconds = fuse_timespec.tv_sec$get(segment);
-		var nanos = fuse_timespec.tv_nsec$get(segment);
+		var seconds = fuse_timespec.tv_sec(segment);
+		var nanos = fuse_timespec.tv_nsec(segment);
 		return Instant.ofEpochSecond(seconds, nanos);
 	}
 
diff --git a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/errno/RuntimeHelper.java b/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/errno/RuntimeHelper.java
deleted file mode 100644
index 0b673e7b..00000000
--- a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/errno/RuntimeHelper.java
+++ /dev/null
@@ -1,245 +0,0 @@
-package org.cryptomator.jfuse.win.extr.errno;
-// Generated by jextract
-
-import java.lang.foreign.Linker;
-import java.lang.foreign.FunctionDescriptor;
-import java.lang.foreign.GroupLayout;
-import java.lang.foreign.SymbolLookup;
-import java.lang.foreign.MemoryLayout;
-import java.lang.foreign.MemorySegment;
-import java.lang.foreign.Arena;
-import java.lang.foreign.SegmentAllocator;
-import java.lang.foreign.ValueLayout;
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.MethodHandles;
-import java.lang.invoke.MethodType;
-import java.io.File;
-import java.nio.file.Path;
-import java.nio.charset.StandardCharsets;
-import java.util.Arrays;
-import java.util.Optional;
-import java.util.stream.Stream;
-
-import java.lang.foreign.AddressLayout;
-import java.lang.foreign.MemoryLayout;
-
-import static java.lang.foreign.Linker.*;
-import static java.lang.foreign.ValueLayout.*;
-
-final class RuntimeHelper {
-
-    private static final Linker LINKER = Linker.nativeLinker();
-    private static final ClassLoader LOADER = RuntimeHelper.class.getClassLoader();
-    private static final MethodHandles.Lookup MH_LOOKUP = MethodHandles.lookup();
-    private static final SymbolLookup SYMBOL_LOOKUP;
-    private static final SegmentAllocator THROWING_ALLOCATOR = (x, y) -> { throw new AssertionError("should not reach here"); };
-    static final AddressLayout POINTER = ValueLayout.ADDRESS.withTargetLayout(MemoryLayout.sequenceLayout(JAVA_BYTE));
-
-    final static SegmentAllocator CONSTANT_ALLOCATOR =
-            (size, align) -> Arena.ofAuto().allocate(size, align);
-
-    static {
-        
-        SymbolLookup loaderLookup = SymbolLookup.loaderLookup();
-        SYMBOL_LOOKUP = name -> loaderLookup.find(name).or(() -> LINKER.defaultLookup().find(name));
-    }
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private RuntimeHelper() {}
-
-    static <T> T requireNonNull(T obj, String symbolName) {
-        if (obj == null) {
-            throw new UnsatisfiedLinkError("unresolved symbol: " + symbolName);
-        }
-        return obj;
-    }
-
-    static MemorySegment lookupGlobalVariable(String name, MemoryLayout layout) {
-        return SYMBOL_LOOKUP.find(name)
-                .map(s -> s.reinterpret(layout.byteSize()))
-                .orElse(null);
-    }
-
-    static MethodHandle downcallHandle(String name, FunctionDescriptor fdesc) {
-        return SYMBOL_LOOKUP.find(name).
-                map(addr -> LINKER.downcallHandle(addr, fdesc)).
-                orElse(null);
-    }
-
-    static MethodHandle downcallHandle(FunctionDescriptor fdesc) {
-        return LINKER.downcallHandle(fdesc);
-    }
-
-    static MethodHandle downcallHandleVariadic(String name, FunctionDescriptor fdesc) {
-        return SYMBOL_LOOKUP.find(name).
-                map(addr -> VarargsInvoker.make(addr, fdesc)).
-                orElse(null);
-    }
-
-    static MethodHandle upcallHandle(Class<?> fi, String name, FunctionDescriptor fdesc) {
-        try {
-            return MH_LOOKUP.findVirtual(fi, name, fdesc.toMethodType());
-        } catch (Throwable ex) {
-            throw new AssertionError(ex);
-        }
-    }
-
-    static <Z> MemorySegment upcallStub(MethodHandle fiHandle, Z z, FunctionDescriptor fdesc, Arena scope) {
-        try {
-            fiHandle = fiHandle.bindTo(z);
-            return LINKER.upcallStub(fiHandle, fdesc, scope);
-        } catch (Throwable ex) {
-            throw new AssertionError(ex);
-        }
-    }
-
-    static MemorySegment asArray(MemorySegment addr, MemoryLayout layout, int numElements, Arena arena) {
-         return addr.reinterpret(numElements * layout.byteSize(), arena, null);
-    }
-
-    // Internals only below this point
-
-    private static final class VarargsInvoker {
-        private static final MethodHandle INVOKE_MH;
-        private final MemorySegment symbol;
-        private final FunctionDescriptor function;
-
-        private VarargsInvoker(MemorySegment symbol, FunctionDescriptor function) {
-            this.symbol = symbol;
-            this.function = function;
-        }
-
-        static {
-            try {
-                INVOKE_MH = MethodHandles.lookup().findVirtual(VarargsInvoker.class, "invoke", MethodType.methodType(Object.class, SegmentAllocator.class, Object[].class));
-            } catch (ReflectiveOperationException e) {
-                throw new RuntimeException(e);
-            }
-        }
-
-        static MethodHandle make(MemorySegment symbol, FunctionDescriptor function) {
-            VarargsInvoker invoker = new VarargsInvoker(symbol, function);
-            MethodHandle handle = INVOKE_MH.bindTo(invoker).asCollector(Object[].class, function.argumentLayouts().size() + 1);
-            MethodType mtype = MethodType.methodType(function.returnLayout().isPresent() ? carrier(function.returnLayout().get(), true) : void.class);
-            for (MemoryLayout layout : function.argumentLayouts()) {
-                mtype = mtype.appendParameterTypes(carrier(layout, false));
-            }
-            mtype = mtype.appendParameterTypes(Object[].class);
-            boolean needsAllocator = function.returnLayout().isPresent() &&
-                                function.returnLayout().get() instanceof GroupLayout;
-            if (needsAllocator) {
-                mtype = mtype.insertParameterTypes(0, SegmentAllocator.class);
-            } else {
-                handle = MethodHandles.insertArguments(handle, 0, THROWING_ALLOCATOR);
-            }
-            return handle.asType(mtype);
-        }
-
-        static Class<?> carrier(MemoryLayout layout, boolean ret) {
-            if (layout instanceof ValueLayout valueLayout) {
-                return valueLayout.carrier();
-            } else if (layout instanceof GroupLayout) {
-                return MemorySegment.class;
-            } else {
-                throw new AssertionError("Cannot get here!");
-            }
-        }
-
-        private Object invoke(SegmentAllocator allocator, Object[] args) throws Throwable {
-            // one trailing Object[]
-            int nNamedArgs = function.argumentLayouts().size();
-            assert(args.length == nNamedArgs + 1);
-            // The last argument is the array of vararg collector
-            Object[] unnamedArgs = (Object[]) args[args.length - 1];
-
-            int argsCount = nNamedArgs + unnamedArgs.length;
-            Class<?>[] argTypes = new Class<?>[argsCount];
-            MemoryLayout[] argLayouts = new MemoryLayout[nNamedArgs + unnamedArgs.length];
-
-            int pos = 0;
-            for (pos = 0; pos < nNamedArgs; pos++) {
-                argLayouts[pos] = function.argumentLayouts().get(pos);
-            }
-
-            assert pos == nNamedArgs;
-            for (Object o: unnamedArgs) {
-                argLayouts[pos] = variadicLayout(normalize(o.getClass()));
-                pos++;
-            }
-            assert pos == argsCount;
-
-            FunctionDescriptor f = (function.returnLayout().isEmpty()) ?
-                    FunctionDescriptor.ofVoid(argLayouts) :
-                    FunctionDescriptor.of(function.returnLayout().get(), argLayouts);
-            MethodHandle mh = LINKER.downcallHandle(symbol, f);
-            boolean needsAllocator = function.returnLayout().isPresent() &&
-                                            function.returnLayout().get() instanceof GroupLayout;
-            if (needsAllocator) {
-                mh = mh.bindTo(allocator);
-            }
-            // flatten argument list so that it can be passed to an asSpreader MH
-            Object[] allArgs = new Object[nNamedArgs + unnamedArgs.length];
-            System.arraycopy(args, 0, allArgs, 0, nNamedArgs);
-            System.arraycopy(unnamedArgs, 0, allArgs, nNamedArgs, unnamedArgs.length);
-
-            return mh.asSpreader(Object[].class, argsCount).invoke(allArgs);
-        }
-
-        private static Class<?> unboxIfNeeded(Class<?> clazz) {
-            if (clazz == Boolean.class) {
-                return boolean.class;
-            } else if (clazz == Void.class) {
-                return void.class;
-            } else if (clazz == Byte.class) {
-                return byte.class;
-            } else if (clazz == Character.class) {
-                return char.class;
-            } else if (clazz == Short.class) {
-                return short.class;
-            } else if (clazz == Integer.class) {
-                return int.class;
-            } else if (clazz == Long.class) {
-                return long.class;
-            } else if (clazz == Float.class) {
-                return float.class;
-            } else if (clazz == Double.class) {
-                return double.class;
-            } else {
-                return clazz;
-            }
-        }
-
-        private Class<?> promote(Class<?> c) {
-            if (c == byte.class || c == char.class || c == short.class || c == int.class) {
-                return long.class;
-            } else if (c == float.class) {
-                return double.class;
-            } else {
-                return c;
-            }
-        }
-
-        private Class<?> normalize(Class<?> c) {
-            c = unboxIfNeeded(c);
-            if (c.isPrimitive()) {
-                return promote(c);
-            }
-            if (c == MemorySegment.class) {
-                return MemorySegment.class;
-            }
-            throw new IllegalArgumentException("Invalid type for ABI: " + c.getTypeName());
-        }
-
-        private MemoryLayout variadicLayout(Class<?> c) {
-            if (c == long.class) {
-                return JAVA_LONG;
-            } else if (c == double.class) {
-                return JAVA_DOUBLE;
-            } else if (c == MemorySegment.class) {
-                return ADDRESS;
-            } else {
-                throw new IllegalArgumentException("Unhandled variadic argument class: " + c);
-            }
-        }
-    }
-}
diff --git a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/errno/constants$0.java b/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/errno/constants$0.java
deleted file mode 100644
index 9abd23a4..00000000
--- a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/errno/constants$0.java
+++ /dev/null
@@ -1,16 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.win.extr.errno;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$0 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$0() {}
-}
-
-
diff --git a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/errno/errno_h.java b/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/errno/errno_h.java
index ba1d191c..147f27f4 100644
--- a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/errno/errno_h.java
+++ b/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/errno/errno_h.java
@@ -2,165 +2,234 @@
 
 package org.cryptomator.jfuse.win.extr.errno;
 
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
+import java.lang.invoke.*;
 import java.lang.foreign.*;
+import java.nio.ByteOrder;
+import java.util.*;
+import java.util.function.*;
+import java.util.stream.*;
+
 import static java.lang.foreign.ValueLayout.*;
-public class errno_h  {
+import static java.lang.foreign.MemoryLayout.PathElement.*;
+
+public class errno_h {
+
+    errno_h() {
+        // Should not be called directly
+    }
+
+    static final Arena LIBRARY_ARENA = Arena.ofAuto();
+    static final boolean TRACE_DOWNCALLS = Boolean.getBoolean("jextract.trace.downcalls");
+
+    static void traceDowncall(String name, Object... args) {
+         String traceArgs = Arrays.stream(args)
+                       .map(Object::toString)
+                       .collect(Collectors.joining(", "));
+         System.out.printf("%s(%s)\n", name, traceArgs);
+    }
 
-    public static final OfByte C_CHAR = JAVA_BYTE;
-    public static final OfShort C_SHORT = JAVA_SHORT;
-    public static final OfInt C_INT = JAVA_INT;
-    public static final OfInt C_LONG = JAVA_INT;
-    public static final OfLong C_LONG_LONG = JAVA_LONG;
-    public static final OfFloat C_FLOAT = JAVA_FLOAT;
-    public static final OfDouble C_DOUBLE = JAVA_DOUBLE;
-    public static final AddressLayout C_POINTER = RuntimeHelper.POINTER;
-    /**
-     * {@snippet :
+    static MemorySegment findOrThrow(String symbol) {
+        return SYMBOL_LOOKUP.find(symbol)
+            .orElseThrow(() -> new UnsatisfiedLinkError("unresolved symbol: " + symbol));
+    }
+
+    static MethodHandle upcallHandle(Class<?> fi, String name, FunctionDescriptor fdesc) {
+        try {
+            return MethodHandles.lookup().findVirtual(fi, name, fdesc.toMethodType());
+        } catch (ReflectiveOperationException ex) {
+            throw new AssertionError(ex);
+        }
+    }
+
+    static MemoryLayout align(MemoryLayout layout, long align) {
+        return switch (layout) {
+            case PaddingLayout p -> p;
+            case ValueLayout v -> v.withByteAlignment(align);
+            case GroupLayout g -> {
+                MemoryLayout[] alignedMembers = g.memberLayouts().stream()
+                        .map(m -> align(m, align)).toArray(MemoryLayout[]::new);
+                yield g instanceof StructLayout ?
+                        MemoryLayout.structLayout(alignedMembers) : MemoryLayout.unionLayout(alignedMembers);
+            }
+            case SequenceLayout s -> MemoryLayout.sequenceLayout(s.elementCount(), align(s.elementLayout(), align));
+        };
+    }
+
+    static final SymbolLookup SYMBOL_LOOKUP = SymbolLookup.loaderLookup()
+            .or(Linker.nativeLinker().defaultLookup());
+
+    public static final ValueLayout.OfBoolean C_BOOL = ValueLayout.JAVA_BOOLEAN;
+    public static final ValueLayout.OfByte C_CHAR = ValueLayout.JAVA_BYTE;
+    public static final ValueLayout.OfShort C_SHORT = ValueLayout.JAVA_SHORT;
+    public static final ValueLayout.OfInt C_INT = ValueLayout.JAVA_INT;
+    public static final ValueLayout.OfLong C_LONG_LONG = ValueLayout.JAVA_LONG;
+    public static final ValueLayout.OfFloat C_FLOAT = ValueLayout.JAVA_FLOAT;
+    public static final ValueLayout.OfDouble C_DOUBLE = ValueLayout.JAVA_DOUBLE;
+    public static final AddressLayout C_POINTER = ValueLayout.ADDRESS
+            .withTargetLayout(MemoryLayout.sequenceLayout(java.lang.Long.MAX_VALUE, JAVA_BYTE));
+    public static final ValueLayout.OfInt C_LONG = ValueLayout.JAVA_INT;
+    public static final ValueLayout.OfDouble C_LONG_DOUBLE = ValueLayout.JAVA_DOUBLE;
+    private static final int ENOENT = (int)2L;
+    /**
+     * {@snippet lang=c :
      * #define ENOENT 2
      * }
      */
     public static int ENOENT() {
-        return (int)2L;
+        return ENOENT;
     }
+    private static final int EIO = (int)5L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define EIO 5
      * }
      */
     public static int EIO() {
-        return (int)5L;
+        return EIO;
     }
+    private static final int E2BIG = (int)7L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define E2BIG 7
      * }
      */
     public static int E2BIG() {
-        return (int)7L;
+        return E2BIG;
     }
+    private static final int EBADF = (int)9L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define EBADF 9
      * }
      */
     public static int EBADF() {
-        return (int)9L;
+        return EBADF;
     }
+    private static final int ENOMEM = (int)12L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define ENOMEM 12
      * }
      */
     public static int ENOMEM() {
-        return (int)12L;
+        return ENOMEM;
     }
+    private static final int EACCES = (int)13L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define EACCES 13
      * }
      */
     public static int EACCES() {
-        return (int)13L;
+        return EACCES;
     }
+    private static final int EEXIST = (int)17L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define EEXIST 17
      * }
      */
     public static int EEXIST() {
-        return (int)17L;
+        return EEXIST;
     }
+    private static final int ENOTDIR = (int)20L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define ENOTDIR 20
      * }
      */
     public static int ENOTDIR() {
-        return (int)20L;
+        return ENOTDIR;
     }
+    private static final int EISDIR = (int)21L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define EISDIR 21
      * }
      */
     public static int EISDIR() {
-        return (int)21L;
+        return EISDIR;
     }
+    private static final int EROFS = (int)30L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define EROFS 30
      * }
      */
     public static int EROFS() {
-        return (int)30L;
+        return EROFS;
     }
+    private static final int ENAMETOOLONG = (int)38L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define ENAMETOOLONG 38
      * }
      */
     public static int ENAMETOOLONG() {
-        return (int)38L;
+        return ENAMETOOLONG;
     }
+    private static final int ENOLCK = (int)39L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define ENOLCK 39
      * }
      */
     public static int ENOLCK() {
-        return (int)39L;
+        return ENOLCK;
     }
+    private static final int ENOSYS = (int)40L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define ENOSYS 40
      * }
      */
     public static int ENOSYS() {
-        return (int)40L;
+        return ENOSYS;
     }
+    private static final int ENOTEMPTY = (int)41L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define ENOTEMPTY 41
      * }
      */
     public static int ENOTEMPTY() {
-        return (int)41L;
+        return ENOTEMPTY;
     }
+    private static final int EINVAL = (int)22L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define EINVAL 22
      * }
      */
     public static int EINVAL() {
-        return (int)22L;
+        return EINVAL;
     }
+    private static final int ERANGE = (int)34L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define ERANGE 34
      * }
      */
     public static int ERANGE() {
-        return (int)34L;
+        return ERANGE;
     }
+    private static final int ENODATA = (int)120L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define ENODATA 120
      * }
      */
     public static int ENODATA() {
-        return (int)120L;
+        return ENODATA;
     }
+    private static final int ENOTSUP = (int)129L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define ENOTSUP 129
      * }
      */
     public static int ENOTSUP() {
-        return (int)129L;
+        return ENOTSUP;
     }
 }
 
-
diff --git a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fcntl/RuntimeHelper.java b/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fcntl/RuntimeHelper.java
deleted file mode 100644
index 09f33097..00000000
--- a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fcntl/RuntimeHelper.java
+++ /dev/null
@@ -1,245 +0,0 @@
-package org.cryptomator.jfuse.win.extr.fcntl;
-// Generated by jextract
-
-import java.lang.foreign.Linker;
-import java.lang.foreign.FunctionDescriptor;
-import java.lang.foreign.GroupLayout;
-import java.lang.foreign.SymbolLookup;
-import java.lang.foreign.MemoryLayout;
-import java.lang.foreign.MemorySegment;
-import java.lang.foreign.Arena;
-import java.lang.foreign.SegmentAllocator;
-import java.lang.foreign.ValueLayout;
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.MethodHandles;
-import java.lang.invoke.MethodType;
-import java.io.File;
-import java.nio.file.Path;
-import java.nio.charset.StandardCharsets;
-import java.util.Arrays;
-import java.util.Optional;
-import java.util.stream.Stream;
-
-import java.lang.foreign.AddressLayout;
-import java.lang.foreign.MemoryLayout;
-
-import static java.lang.foreign.Linker.*;
-import static java.lang.foreign.ValueLayout.*;
-
-final class RuntimeHelper {
-
-    private static final Linker LINKER = Linker.nativeLinker();
-    private static final ClassLoader LOADER = RuntimeHelper.class.getClassLoader();
-    private static final MethodHandles.Lookup MH_LOOKUP = MethodHandles.lookup();
-    private static final SymbolLookup SYMBOL_LOOKUP;
-    private static final SegmentAllocator THROWING_ALLOCATOR = (x, y) -> { throw new AssertionError("should not reach here"); };
-    static final AddressLayout POINTER = ValueLayout.ADDRESS.withTargetLayout(MemoryLayout.sequenceLayout(JAVA_BYTE));
-
-    final static SegmentAllocator CONSTANT_ALLOCATOR =
-            (size, align) -> Arena.ofAuto().allocate(size, align);
-
-    static {
-        
-        SymbolLookup loaderLookup = SymbolLookup.loaderLookup();
-        SYMBOL_LOOKUP = name -> loaderLookup.find(name).or(() -> LINKER.defaultLookup().find(name));
-    }
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private RuntimeHelper() {}
-
-    static <T> T requireNonNull(T obj, String symbolName) {
-        if (obj == null) {
-            throw new UnsatisfiedLinkError("unresolved symbol: " + symbolName);
-        }
-        return obj;
-    }
-
-    static MemorySegment lookupGlobalVariable(String name, MemoryLayout layout) {
-        return SYMBOL_LOOKUP.find(name)
-                .map(s -> s.reinterpret(layout.byteSize()))
-                .orElse(null);
-    }
-
-    static MethodHandle downcallHandle(String name, FunctionDescriptor fdesc) {
-        return SYMBOL_LOOKUP.find(name).
-                map(addr -> LINKER.downcallHandle(addr, fdesc)).
-                orElse(null);
-    }
-
-    static MethodHandle downcallHandle(FunctionDescriptor fdesc) {
-        return LINKER.downcallHandle(fdesc);
-    }
-
-    static MethodHandle downcallHandleVariadic(String name, FunctionDescriptor fdesc) {
-        return SYMBOL_LOOKUP.find(name).
-                map(addr -> VarargsInvoker.make(addr, fdesc)).
-                orElse(null);
-    }
-
-    static MethodHandle upcallHandle(Class<?> fi, String name, FunctionDescriptor fdesc) {
-        try {
-            return MH_LOOKUP.findVirtual(fi, name, fdesc.toMethodType());
-        } catch (Throwable ex) {
-            throw new AssertionError(ex);
-        }
-    }
-
-    static <Z> MemorySegment upcallStub(MethodHandle fiHandle, Z z, FunctionDescriptor fdesc, Arena scope) {
-        try {
-            fiHandle = fiHandle.bindTo(z);
-            return LINKER.upcallStub(fiHandle, fdesc, scope);
-        } catch (Throwable ex) {
-            throw new AssertionError(ex);
-        }
-    }
-
-    static MemorySegment asArray(MemorySegment addr, MemoryLayout layout, int numElements, Arena arena) {
-         return addr.reinterpret(numElements * layout.byteSize(), arena, null);
-    }
-
-    // Internals only below this point
-
-    private static final class VarargsInvoker {
-        private static final MethodHandle INVOKE_MH;
-        private final MemorySegment symbol;
-        private final FunctionDescriptor function;
-
-        private VarargsInvoker(MemorySegment symbol, FunctionDescriptor function) {
-            this.symbol = symbol;
-            this.function = function;
-        }
-
-        static {
-            try {
-                INVOKE_MH = MethodHandles.lookup().findVirtual(VarargsInvoker.class, "invoke", MethodType.methodType(Object.class, SegmentAllocator.class, Object[].class));
-            } catch (ReflectiveOperationException e) {
-                throw new RuntimeException(e);
-            }
-        }
-
-        static MethodHandle make(MemorySegment symbol, FunctionDescriptor function) {
-            VarargsInvoker invoker = new VarargsInvoker(symbol, function);
-            MethodHandle handle = INVOKE_MH.bindTo(invoker).asCollector(Object[].class, function.argumentLayouts().size() + 1);
-            MethodType mtype = MethodType.methodType(function.returnLayout().isPresent() ? carrier(function.returnLayout().get(), true) : void.class);
-            for (MemoryLayout layout : function.argumentLayouts()) {
-                mtype = mtype.appendParameterTypes(carrier(layout, false));
-            }
-            mtype = mtype.appendParameterTypes(Object[].class);
-            boolean needsAllocator = function.returnLayout().isPresent() &&
-                                function.returnLayout().get() instanceof GroupLayout;
-            if (needsAllocator) {
-                mtype = mtype.insertParameterTypes(0, SegmentAllocator.class);
-            } else {
-                handle = MethodHandles.insertArguments(handle, 0, THROWING_ALLOCATOR);
-            }
-            return handle.asType(mtype);
-        }
-
-        static Class<?> carrier(MemoryLayout layout, boolean ret) {
-            if (layout instanceof ValueLayout valueLayout) {
-                return valueLayout.carrier();
-            } else if (layout instanceof GroupLayout) {
-                return MemorySegment.class;
-            } else {
-                throw new AssertionError("Cannot get here!");
-            }
-        }
-
-        private Object invoke(SegmentAllocator allocator, Object[] args) throws Throwable {
-            // one trailing Object[]
-            int nNamedArgs = function.argumentLayouts().size();
-            assert(args.length == nNamedArgs + 1);
-            // The last argument is the array of vararg collector
-            Object[] unnamedArgs = (Object[]) args[args.length - 1];
-
-            int argsCount = nNamedArgs + unnamedArgs.length;
-            Class<?>[] argTypes = new Class<?>[argsCount];
-            MemoryLayout[] argLayouts = new MemoryLayout[nNamedArgs + unnamedArgs.length];
-
-            int pos = 0;
-            for (pos = 0; pos < nNamedArgs; pos++) {
-                argLayouts[pos] = function.argumentLayouts().get(pos);
-            }
-
-            assert pos == nNamedArgs;
-            for (Object o: unnamedArgs) {
-                argLayouts[pos] = variadicLayout(normalize(o.getClass()));
-                pos++;
-            }
-            assert pos == argsCount;
-
-            FunctionDescriptor f = (function.returnLayout().isEmpty()) ?
-                    FunctionDescriptor.ofVoid(argLayouts) :
-                    FunctionDescriptor.of(function.returnLayout().get(), argLayouts);
-            MethodHandle mh = LINKER.downcallHandle(symbol, f);
-            boolean needsAllocator = function.returnLayout().isPresent() &&
-                                            function.returnLayout().get() instanceof GroupLayout;
-            if (needsAllocator) {
-                mh = mh.bindTo(allocator);
-            }
-            // flatten argument list so that it can be passed to an asSpreader MH
-            Object[] allArgs = new Object[nNamedArgs + unnamedArgs.length];
-            System.arraycopy(args, 0, allArgs, 0, nNamedArgs);
-            System.arraycopy(unnamedArgs, 0, allArgs, nNamedArgs, unnamedArgs.length);
-
-            return mh.asSpreader(Object[].class, argsCount).invoke(allArgs);
-        }
-
-        private static Class<?> unboxIfNeeded(Class<?> clazz) {
-            if (clazz == Boolean.class) {
-                return boolean.class;
-            } else if (clazz == Void.class) {
-                return void.class;
-            } else if (clazz == Byte.class) {
-                return byte.class;
-            } else if (clazz == Character.class) {
-                return char.class;
-            } else if (clazz == Short.class) {
-                return short.class;
-            } else if (clazz == Integer.class) {
-                return int.class;
-            } else if (clazz == Long.class) {
-                return long.class;
-            } else if (clazz == Float.class) {
-                return float.class;
-            } else if (clazz == Double.class) {
-                return double.class;
-            } else {
-                return clazz;
-            }
-        }
-
-        private Class<?> promote(Class<?> c) {
-            if (c == byte.class || c == char.class || c == short.class || c == int.class) {
-                return long.class;
-            } else if (c == float.class) {
-                return double.class;
-            } else {
-                return c;
-            }
-        }
-
-        private Class<?> normalize(Class<?> c) {
-            c = unboxIfNeeded(c);
-            if (c.isPrimitive()) {
-                return promote(c);
-            }
-            if (c == MemorySegment.class) {
-                return MemorySegment.class;
-            }
-            throw new IllegalArgumentException("Invalid type for ABI: " + c.getTypeName());
-        }
-
-        private MemoryLayout variadicLayout(Class<?> c) {
-            if (c == long.class) {
-                return JAVA_LONG;
-            } else if (c == double.class) {
-                return JAVA_DOUBLE;
-            } else if (c == MemorySegment.class) {
-                return ADDRESS;
-            } else {
-                throw new IllegalArgumentException("Unhandled variadic argument class: " + c);
-            }
-        }
-    }
-}
diff --git a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fcntl/constants$0.java b/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fcntl/constants$0.java
deleted file mode 100644
index f3672ad9..00000000
--- a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fcntl/constants$0.java
+++ /dev/null
@@ -1,16 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.win.extr.fcntl;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$0 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$0() {}
-}
-
-
diff --git a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fcntl/fcntl_h.java b/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fcntl/fcntl_h.java
index e79fd070..4a028550 100644
--- a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fcntl/fcntl_h.java
+++ b/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fcntl/fcntl_h.java
@@ -2,77 +2,135 @@
 
 package org.cryptomator.jfuse.win.extr.fcntl;
 
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
+import java.lang.invoke.*;
 import java.lang.foreign.*;
+import java.nio.ByteOrder;
+import java.util.*;
+import java.util.function.*;
+import java.util.stream.*;
+
 import static java.lang.foreign.ValueLayout.*;
-public class fcntl_h  {
+import static java.lang.foreign.MemoryLayout.PathElement.*;
+
+public class fcntl_h {
+
+    fcntl_h() {
+        // Should not be called directly
+    }
+
+    static final Arena LIBRARY_ARENA = Arena.ofAuto();
+    static final boolean TRACE_DOWNCALLS = Boolean.getBoolean("jextract.trace.downcalls");
+
+    static void traceDowncall(String name, Object... args) {
+         String traceArgs = Arrays.stream(args)
+                       .map(Object::toString)
+                       .collect(Collectors.joining(", "));
+         System.out.printf("%s(%s)\n", name, traceArgs);
+    }
 
-    public static final OfByte C_CHAR = JAVA_BYTE;
-    public static final OfShort C_SHORT = JAVA_SHORT;
-    public static final OfInt C_INT = JAVA_INT;
-    public static final OfInt C_LONG = JAVA_INT;
-    public static final OfLong C_LONG_LONG = JAVA_LONG;
-    public static final OfFloat C_FLOAT = JAVA_FLOAT;
-    public static final OfDouble C_DOUBLE = JAVA_DOUBLE;
-    public static final AddressLayout C_POINTER = RuntimeHelper.POINTER;
+    static MemorySegment findOrThrow(String symbol) {
+        return SYMBOL_LOOKUP.find(symbol)
+            .orElseThrow(() -> new UnsatisfiedLinkError("unresolved symbol: " + symbol));
+    }
+
+    static MethodHandle upcallHandle(Class<?> fi, String name, FunctionDescriptor fdesc) {
+        try {
+            return MethodHandles.lookup().findVirtual(fi, name, fdesc.toMethodType());
+        } catch (ReflectiveOperationException ex) {
+            throw new AssertionError(ex);
+        }
+    }
+
+    static MemoryLayout align(MemoryLayout layout, long align) {
+        return switch (layout) {
+            case PaddingLayout p -> p;
+            case ValueLayout v -> v.withByteAlignment(align);
+            case GroupLayout g -> {
+                MemoryLayout[] alignedMembers = g.memberLayouts().stream()
+                        .map(m -> align(m, align)).toArray(MemoryLayout[]::new);
+                yield g instanceof StructLayout ?
+                        MemoryLayout.structLayout(alignedMembers) : MemoryLayout.unionLayout(alignedMembers);
+            }
+            case SequenceLayout s -> MemoryLayout.sequenceLayout(s.elementCount(), align(s.elementLayout(), align));
+        };
+    }
+
+    static final SymbolLookup SYMBOL_LOOKUP = SymbolLookup.loaderLookup()
+            .or(Linker.nativeLinker().defaultLookup());
+
+    public static final ValueLayout.OfBoolean C_BOOL = ValueLayout.JAVA_BOOLEAN;
+    public static final ValueLayout.OfByte C_CHAR = ValueLayout.JAVA_BYTE;
+    public static final ValueLayout.OfShort C_SHORT = ValueLayout.JAVA_SHORT;
+    public static final ValueLayout.OfInt C_INT = ValueLayout.JAVA_INT;
+    public static final ValueLayout.OfLong C_LONG_LONG = ValueLayout.JAVA_LONG;
+    public static final ValueLayout.OfFloat C_FLOAT = ValueLayout.JAVA_FLOAT;
+    public static final ValueLayout.OfDouble C_DOUBLE = ValueLayout.JAVA_DOUBLE;
+    public static final AddressLayout C_POINTER = ValueLayout.ADDRESS
+            .withTargetLayout(MemoryLayout.sequenceLayout(java.lang.Long.MAX_VALUE, JAVA_BYTE));
+    public static final ValueLayout.OfInt C_LONG = ValueLayout.JAVA_INT;
+    public static final ValueLayout.OfDouble C_LONG_DOUBLE = ValueLayout.JAVA_DOUBLE;
+    private static final int O_RDONLY = (int)0L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define O_RDONLY 0
      * }
      */
     public static int O_RDONLY() {
-        return (int)0L;
+        return O_RDONLY;
     }
+    private static final int O_WRONLY = (int)1L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define O_WRONLY 1
      * }
      */
     public static int O_WRONLY() {
-        return (int)1L;
+        return O_WRONLY;
     }
+    private static final int O_RDWR = (int)2L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define O_RDWR 2
      * }
      */
     public static int O_RDWR() {
-        return (int)2L;
+        return O_RDWR;
     }
+    private static final int O_APPEND = (int)8L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define O_APPEND 8
      * }
      */
     public static int O_APPEND() {
-        return (int)8L;
+        return O_APPEND;
     }
+    private static final int O_CREAT = (int)256L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define O_CREAT 256
      * }
      */
     public static int O_CREAT() {
-        return (int)256L;
+        return O_CREAT;
     }
+    private static final int O_TRUNC = (int)512L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define O_TRUNC 512
      * }
      */
     public static int O_TRUNC() {
-        return (int)512L;
+        return O_TRUNC;
     }
+    private static final int O_EXCL = (int)1024L;
     /**
-     * {@snippet :
+     * {@snippet lang=c :
      * #define O_EXCL 1024
      * }
      */
     public static int O_EXCL() {
-        return (int)1024L;
+        return O_EXCL;
     }
 }
 
-
diff --git a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse2/RuntimeHelper.java b/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse2/RuntimeHelper.java
deleted file mode 100644
index 5fa763ce..00000000
--- a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse2/RuntimeHelper.java
+++ /dev/null
@@ -1,245 +0,0 @@
-package org.cryptomator.jfuse.win.extr.fuse2;
-// Generated by jextract
-
-import java.lang.foreign.Linker;
-import java.lang.foreign.FunctionDescriptor;
-import java.lang.foreign.GroupLayout;
-import java.lang.foreign.SymbolLookup;
-import java.lang.foreign.MemoryLayout;
-import java.lang.foreign.MemorySegment;
-import java.lang.foreign.Arena;
-import java.lang.foreign.SegmentAllocator;
-import java.lang.foreign.ValueLayout;
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.MethodHandles;
-import java.lang.invoke.MethodType;
-import java.io.File;
-import java.nio.file.Path;
-import java.nio.charset.StandardCharsets;
-import java.util.Arrays;
-import java.util.Optional;
-import java.util.stream.Stream;
-
-import java.lang.foreign.AddressLayout;
-import java.lang.foreign.MemoryLayout;
-
-import static java.lang.foreign.Linker.*;
-import static java.lang.foreign.ValueLayout.*;
-
-final class RuntimeHelper {
-
-    private static final Linker LINKER = Linker.nativeLinker();
-    private static final ClassLoader LOADER = RuntimeHelper.class.getClassLoader();
-    private static final MethodHandles.Lookup MH_LOOKUP = MethodHandles.lookup();
-    private static final SymbolLookup SYMBOL_LOOKUP;
-    private static final SegmentAllocator THROWING_ALLOCATOR = (x, y) -> { throw new AssertionError("should not reach here"); };
-    static final AddressLayout POINTER = ValueLayout.ADDRESS.withTargetLayout(MemoryLayout.sequenceLayout(JAVA_BYTE));
-
-    final static SegmentAllocator CONSTANT_ALLOCATOR =
-            (size, align) -> Arena.ofAuto().allocate(size, align);
-
-    static {
-        
-        SymbolLookup loaderLookup = SymbolLookup.loaderLookup();
-        SYMBOL_LOOKUP = name -> loaderLookup.find(name).or(() -> LINKER.defaultLookup().find(name));
-    }
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private RuntimeHelper() {}
-
-    static <T> T requireNonNull(T obj, String symbolName) {
-        if (obj == null) {
-            throw new UnsatisfiedLinkError("unresolved symbol: " + symbolName);
-        }
-        return obj;
-    }
-
-    static MemorySegment lookupGlobalVariable(String name, MemoryLayout layout) {
-        return SYMBOL_LOOKUP.find(name)
-                .map(s -> s.reinterpret(layout.byteSize()))
-                .orElse(null);
-    }
-
-    static MethodHandle downcallHandle(String name, FunctionDescriptor fdesc) {
-        return SYMBOL_LOOKUP.find(name).
-                map(addr -> LINKER.downcallHandle(addr, fdesc)).
-                orElse(null);
-    }
-
-    static MethodHandle downcallHandle(FunctionDescriptor fdesc) {
-        return LINKER.downcallHandle(fdesc);
-    }
-
-    static MethodHandle downcallHandleVariadic(String name, FunctionDescriptor fdesc) {
-        return SYMBOL_LOOKUP.find(name).
-                map(addr -> VarargsInvoker.make(addr, fdesc)).
-                orElse(null);
-    }
-
-    static MethodHandle upcallHandle(Class<?> fi, String name, FunctionDescriptor fdesc) {
-        try {
-            return MH_LOOKUP.findVirtual(fi, name, fdesc.toMethodType());
-        } catch (Throwable ex) {
-            throw new AssertionError(ex);
-        }
-    }
-
-    static <Z> MemorySegment upcallStub(MethodHandle fiHandle, Z z, FunctionDescriptor fdesc, Arena scope) {
-        try {
-            fiHandle = fiHandle.bindTo(z);
-            return LINKER.upcallStub(fiHandle, fdesc, scope);
-        } catch (Throwable ex) {
-            throw new AssertionError(ex);
-        }
-    }
-
-    static MemorySegment asArray(MemorySegment addr, MemoryLayout layout, int numElements, Arena arena) {
-         return addr.reinterpret(numElements * layout.byteSize(), arena, null);
-    }
-
-    // Internals only below this point
-
-    private static final class VarargsInvoker {
-        private static final MethodHandle INVOKE_MH;
-        private final MemorySegment symbol;
-        private final FunctionDescriptor function;
-
-        private VarargsInvoker(MemorySegment symbol, FunctionDescriptor function) {
-            this.symbol = symbol;
-            this.function = function;
-        }
-
-        static {
-            try {
-                INVOKE_MH = MethodHandles.lookup().findVirtual(VarargsInvoker.class, "invoke", MethodType.methodType(Object.class, SegmentAllocator.class, Object[].class));
-            } catch (ReflectiveOperationException e) {
-                throw new RuntimeException(e);
-            }
-        }
-
-        static MethodHandle make(MemorySegment symbol, FunctionDescriptor function) {
-            VarargsInvoker invoker = new VarargsInvoker(symbol, function);
-            MethodHandle handle = INVOKE_MH.bindTo(invoker).asCollector(Object[].class, function.argumentLayouts().size() + 1);
-            MethodType mtype = MethodType.methodType(function.returnLayout().isPresent() ? carrier(function.returnLayout().get(), true) : void.class);
-            for (MemoryLayout layout : function.argumentLayouts()) {
-                mtype = mtype.appendParameterTypes(carrier(layout, false));
-            }
-            mtype = mtype.appendParameterTypes(Object[].class);
-            boolean needsAllocator = function.returnLayout().isPresent() &&
-                                function.returnLayout().get() instanceof GroupLayout;
-            if (needsAllocator) {
-                mtype = mtype.insertParameterTypes(0, SegmentAllocator.class);
-            } else {
-                handle = MethodHandles.insertArguments(handle, 0, THROWING_ALLOCATOR);
-            }
-            return handle.asType(mtype);
-        }
-
-        static Class<?> carrier(MemoryLayout layout, boolean ret) {
-            if (layout instanceof ValueLayout valueLayout) {
-                return valueLayout.carrier();
-            } else if (layout instanceof GroupLayout) {
-                return MemorySegment.class;
-            } else {
-                throw new AssertionError("Cannot get here!");
-            }
-        }
-
-        private Object invoke(SegmentAllocator allocator, Object[] args) throws Throwable {
-            // one trailing Object[]
-            int nNamedArgs = function.argumentLayouts().size();
-            assert(args.length == nNamedArgs + 1);
-            // The last argument is the array of vararg collector
-            Object[] unnamedArgs = (Object[]) args[args.length - 1];
-
-            int argsCount = nNamedArgs + unnamedArgs.length;
-            Class<?>[] argTypes = new Class<?>[argsCount];
-            MemoryLayout[] argLayouts = new MemoryLayout[nNamedArgs + unnamedArgs.length];
-
-            int pos = 0;
-            for (pos = 0; pos < nNamedArgs; pos++) {
-                argLayouts[pos] = function.argumentLayouts().get(pos);
-            }
-
-            assert pos == nNamedArgs;
-            for (Object o: unnamedArgs) {
-                argLayouts[pos] = variadicLayout(normalize(o.getClass()));
-                pos++;
-            }
-            assert pos == argsCount;
-
-            FunctionDescriptor f = (function.returnLayout().isEmpty()) ?
-                    FunctionDescriptor.ofVoid(argLayouts) :
-                    FunctionDescriptor.of(function.returnLayout().get(), argLayouts);
-            MethodHandle mh = LINKER.downcallHandle(symbol, f);
-            boolean needsAllocator = function.returnLayout().isPresent() &&
-                                            function.returnLayout().get() instanceof GroupLayout;
-            if (needsAllocator) {
-                mh = mh.bindTo(allocator);
-            }
-            // flatten argument list so that it can be passed to an asSpreader MH
-            Object[] allArgs = new Object[nNamedArgs + unnamedArgs.length];
-            System.arraycopy(args, 0, allArgs, 0, nNamedArgs);
-            System.arraycopy(unnamedArgs, 0, allArgs, nNamedArgs, unnamedArgs.length);
-
-            return mh.asSpreader(Object[].class, argsCount).invoke(allArgs);
-        }
-
-        private static Class<?> unboxIfNeeded(Class<?> clazz) {
-            if (clazz == Boolean.class) {
-                return boolean.class;
-            } else if (clazz == Void.class) {
-                return void.class;
-            } else if (clazz == Byte.class) {
-                return byte.class;
-            } else if (clazz == Character.class) {
-                return char.class;
-            } else if (clazz == Short.class) {
-                return short.class;
-            } else if (clazz == Integer.class) {
-                return int.class;
-            } else if (clazz == Long.class) {
-                return long.class;
-            } else if (clazz == Float.class) {
-                return float.class;
-            } else if (clazz == Double.class) {
-                return double.class;
-            } else {
-                return clazz;
-            }
-        }
-
-        private Class<?> promote(Class<?> c) {
-            if (c == byte.class || c == char.class || c == short.class || c == int.class) {
-                return long.class;
-            } else if (c == float.class) {
-                return double.class;
-            } else {
-                return c;
-            }
-        }
-
-        private Class<?> normalize(Class<?> c) {
-            c = unboxIfNeeded(c);
-            if (c.isPrimitive()) {
-                return promote(c);
-            }
-            if (c == MemorySegment.class) {
-                return MemorySegment.class;
-            }
-            throw new IllegalArgumentException("Invalid type for ABI: " + c.getTypeName());
-        }
-
-        private MemoryLayout variadicLayout(Class<?> c) {
-            if (c == long.class) {
-                return JAVA_LONG;
-            } else if (c == double.class) {
-                return JAVA_DOUBLE;
-            } else if (c == MemorySegment.class) {
-                return ADDRESS;
-            } else {
-                throw new IllegalArgumentException("Unhandled variadic argument class: " + c);
-            }
-        }
-    }
-}
diff --git a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse2/constants$0.java b/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse2/constants$0.java
deleted file mode 100644
index 352eac80..00000000
--- a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse2/constants$0.java
+++ /dev/null
@@ -1,36 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.win.extr.fuse2;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$0 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$0() {}
-    static final StructLayout const$0 = MemoryLayout.structLayout(
-        JAVA_INT.withName("argc"),
-        MemoryLayout.paddingLayout(4),
-        RuntimeHelper.POINTER.withName("argv"),
-        JAVA_INT.withName("allocated"),
-        MemoryLayout.paddingLayout(4)
-    ).withName("fuse_args");
-    static final VarHandle const$1 = constants$0.const$0.varHandle(MemoryLayout.PathElement.groupElement("argc"));
-    static final VarHandle const$2 = constants$0.const$0.varHandle(MemoryLayout.PathElement.groupElement("argv"));
-    static final VarHandle const$3 = constants$0.const$0.varHandle(MemoryLayout.PathElement.groupElement("allocated"));
-    static final FunctionDescriptor const$4 = FunctionDescriptor.of(JAVA_INT,
-        RuntimeHelper.POINTER,
-        RuntimeHelper.POINTER,
-        RuntimeHelper.POINTER,
-        RuntimeHelper.POINTER
-    );
-    static final MethodHandle const$5 = RuntimeHelper.downcallHandle(
-        "fuse_parse_cmdline",
-        constants$0.const$4
-    );
-}
-
-
diff --git a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse2/fuse2_h.java b/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse2/fuse2_h.java
index ab3a8e8f..4785ac5e 100644
--- a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse2/fuse2_h.java
+++ b/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse2/fuse2_h.java
@@ -2,37 +2,122 @@
 
 package org.cryptomator.jfuse.win.extr.fuse2;
 
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
+import java.lang.invoke.*;
 import java.lang.foreign.*;
+import java.nio.ByteOrder;
+import java.util.*;
+import java.util.function.*;
+import java.util.stream.*;
+
 import static java.lang.foreign.ValueLayout.*;
-public class fuse2_h  {
-
-    public static final OfByte C_CHAR = JAVA_BYTE;
-    public static final OfShort C_SHORT = JAVA_SHORT;
-    public static final OfInt C_INT = JAVA_INT;
-    public static final OfInt C_LONG = JAVA_INT;
-    public static final OfLong C_LONG_LONG = JAVA_LONG;
-    public static final OfFloat C_FLOAT = JAVA_FLOAT;
-    public static final OfDouble C_DOUBLE = JAVA_DOUBLE;
-    public static final AddressLayout C_POINTER = RuntimeHelper.POINTER;
-    public static MethodHandle fuse_parse_cmdline$MH() {
-        return RuntimeHelper.requireNonNull(constants$0.const$5,"fuse_parse_cmdline");
+import static java.lang.foreign.MemoryLayout.PathElement.*;
+
+public class fuse2_h {
+
+    fuse2_h() {
+        // Should not be called directly
+    }
+
+    static final Arena LIBRARY_ARENA = Arena.ofAuto();
+    static final boolean TRACE_DOWNCALLS = Boolean.getBoolean("jextract.trace.downcalls");
+
+    static void traceDowncall(String name, Object... args) {
+         String traceArgs = Arrays.stream(args)
+                       .map(Object::toString)
+                       .collect(Collectors.joining(", "));
+         System.out.printf("%s(%s)\n", name, traceArgs);
+    }
+
+    static MemorySegment findOrThrow(String symbol) {
+        return SYMBOL_LOOKUP.find(symbol)
+            .orElseThrow(() -> new UnsatisfiedLinkError("unresolved symbol: " + symbol));
+    }
+
+    static MethodHandle upcallHandle(Class<?> fi, String name, FunctionDescriptor fdesc) {
+        try {
+            return MethodHandles.lookup().findVirtual(fi, name, fdesc.toMethodType());
+        } catch (ReflectiveOperationException ex) {
+            throw new AssertionError(ex);
+        }
+    }
+
+    static MemoryLayout align(MemoryLayout layout, long align) {
+        return switch (layout) {
+            case PaddingLayout p -> p;
+            case ValueLayout v -> v.withByteAlignment(align);
+            case GroupLayout g -> {
+                MemoryLayout[] alignedMembers = g.memberLayouts().stream()
+                        .map(m -> align(m, align)).toArray(MemoryLayout[]::new);
+                yield g instanceof StructLayout ?
+                        MemoryLayout.structLayout(alignedMembers) : MemoryLayout.unionLayout(alignedMembers);
+            }
+            case SequenceLayout s -> MemoryLayout.sequenceLayout(s.elementCount(), align(s.elementLayout(), align));
+        };
+    }
+
+    static final SymbolLookup SYMBOL_LOOKUP = SymbolLookup.loaderLookup()
+            .or(Linker.nativeLinker().defaultLookup());
+
+    public static final ValueLayout.OfBoolean C_BOOL = ValueLayout.JAVA_BOOLEAN;
+    public static final ValueLayout.OfByte C_CHAR = ValueLayout.JAVA_BYTE;
+    public static final ValueLayout.OfShort C_SHORT = ValueLayout.JAVA_SHORT;
+    public static final ValueLayout.OfInt C_INT = ValueLayout.JAVA_INT;
+    public static final ValueLayout.OfLong C_LONG_LONG = ValueLayout.JAVA_LONG;
+    public static final ValueLayout.OfFloat C_FLOAT = ValueLayout.JAVA_FLOAT;
+    public static final ValueLayout.OfDouble C_DOUBLE = ValueLayout.JAVA_DOUBLE;
+    public static final AddressLayout C_POINTER = ValueLayout.ADDRESS
+            .withTargetLayout(MemoryLayout.sequenceLayout(java.lang.Long.MAX_VALUE, JAVA_BYTE));
+    public static final ValueLayout.OfInt C_LONG = ValueLayout.JAVA_INT;
+    public static final ValueLayout.OfDouble C_LONG_DOUBLE = ValueLayout.JAVA_DOUBLE;
+
+    private static class fuse_parse_cmdline {
+        public static final FunctionDescriptor DESC = FunctionDescriptor.of(
+            fuse2_h.C_INT,
+            fuse2_h.C_POINTER,
+            fuse2_h.C_POINTER,
+            fuse2_h.C_POINTER,
+            fuse2_h.C_POINTER
+        );
+
+        public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(
+                    fuse2_h.findOrThrow("fuse_parse_cmdline"),
+                    DESC);
+    }
+
+    /**
+     * Function descriptor for:
+     * {@snippet lang=c :
+     * int fuse_parse_cmdline(struct fuse_args *args, char **mountpoint, int *multithreaded, int *foreground)
+     * }
+     */
+    public static FunctionDescriptor fuse_parse_cmdline$descriptor() {
+        return fuse_parse_cmdline.DESC;
+    }
+
+    /**
+     * Downcall method handle for:
+     * {@snippet lang=c :
+     * int fuse_parse_cmdline(struct fuse_args *args, char **mountpoint, int *multithreaded, int *foreground)
+     * }
+     */
+    public static MethodHandle fuse_parse_cmdline$handle() {
+        return fuse_parse_cmdline.HANDLE;
     }
     /**
-     * {@snippet :
-     * int fuse_parse_cmdline(struct fuse_args* args, char** mountpoint, int* multithreaded, int* foreground);
+     * {@snippet lang=c :
+     * int fuse_parse_cmdline(struct fuse_args *args, char **mountpoint, int *multithreaded, int *foreground)
      * }
      */
     public static int fuse_parse_cmdline(MemorySegment args, MemorySegment mountpoint, MemorySegment multithreaded, MemorySegment foreground) {
-        var mh$ = fuse_parse_cmdline$MH();
+        var mh$ = fuse_parse_cmdline.HANDLE;
         try {
+            if (TRACE_DOWNCALLS) {
+                traceDowncall("fuse_parse_cmdline", args, mountpoint, multithreaded, foreground);
+            }
             return (int)mh$.invokeExact(args, mountpoint, multithreaded, foreground);
         } catch (Throwable ex$) {
-            throw new AssertionError("should not reach here", ex$);
+           throw new AssertionError("should not reach here", ex$);
         }
     }
 }
 
-
diff --git a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse2/fuse_args.java b/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse2/fuse_args.java
index 32e2821d..365ca9d8 100644
--- a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse2/fuse_args.java
+++ b/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse2/fuse_args.java
@@ -2,112 +2,220 @@
 
 package org.cryptomator.jfuse.win.extr.fuse2;
 
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
+import java.lang.invoke.*;
 import java.lang.foreign.*;
+import java.nio.ByteOrder;
+import java.util.*;
+import java.util.function.*;
+import java.util.stream.*;
+
 import static java.lang.foreign.ValueLayout.*;
+import static java.lang.foreign.MemoryLayout.PathElement.*;
+
 /**
- * {@snippet :
+ * {@snippet lang=c :
  * struct fuse_args {
  *     int argc;
- *     char** argv;
+ *     char **argv;
  *     int allocated;
- * };
+ * }
  * }
  */
 public class fuse_args {
 
-    public static MemoryLayout $LAYOUT() {
-        return constants$0.const$0;
+    fuse_args() {
+        // Should not be called directly
+    }
+
+    private static final GroupLayout $LAYOUT = MemoryLayout.structLayout(
+        fuse2_h.C_INT.withName("argc"),
+        MemoryLayout.paddingLayout(4),
+        fuse2_h.C_POINTER.withName("argv"),
+        fuse2_h.C_INT.withName("allocated"),
+        MemoryLayout.paddingLayout(4)
+    ).withName("fuse_args");
+
+    /**
+     * The layout of this struct
+     */
+    public static final GroupLayout layout() {
+        return $LAYOUT;
     }
-    public static VarHandle argc$VH() {
-        return constants$0.const$1;
+
+    private static final OfInt argc$LAYOUT = (OfInt)$LAYOUT.select(groupElement("argc"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int argc
+     * }
+     */
+    public static final OfInt argc$layout() {
+        return argc$LAYOUT;
     }
+
+    private static final long argc$OFFSET = 0;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int argc
+     * }
+     */
+    public static final long argc$offset() {
+        return argc$OFFSET;
+    }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int argc;
+     * {@snippet lang=c :
+     * int argc
      * }
      */
-    public static int argc$get(MemorySegment seg) {
-        return (int)constants$0.const$1.get(seg);
+    public static int argc(MemorySegment struct) {
+        return struct.get(argc$LAYOUT, argc$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int argc;
+     * {@snippet lang=c :
+     * int argc
      * }
      */
-    public static void argc$set(MemorySegment seg, int x) {
-        constants$0.const$1.set(seg, x);
+    public static void argc(MemorySegment struct, int fieldValue) {
+        struct.set(argc$LAYOUT, argc$OFFSET, fieldValue);
     }
-    public static int argc$get(MemorySegment seg, long index) {
-        return (int)constants$0.const$1.get(seg.asSlice(index*sizeof()));
-    }
-    public static void argc$set(MemorySegment seg, long index, int x) {
-        constants$0.const$1.set(seg.asSlice(index*sizeof()), x);
+
+    private static final AddressLayout argv$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("argv"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * char **argv
+     * }
+     */
+    public static final AddressLayout argv$layout() {
+        return argv$LAYOUT;
     }
-    public static VarHandle argv$VH() {
-        return constants$0.const$2;
+
+    private static final long argv$OFFSET = 8;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * char **argv
+     * }
+     */
+    public static final long argv$offset() {
+        return argv$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * char** argv;
+     * {@snippet lang=c :
+     * char **argv
      * }
      */
-    public static MemorySegment argv$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$0.const$2.get(seg);
+    public static MemorySegment argv(MemorySegment struct) {
+        return struct.get(argv$LAYOUT, argv$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * char** argv;
+     * {@snippet lang=c :
+     * char **argv
      * }
      */
-    public static void argv$set(MemorySegment seg, MemorySegment x) {
-        constants$0.const$2.set(seg, x);
-    }
-    public static MemorySegment argv$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$0.const$2.get(seg.asSlice(index*sizeof()));
+    public static void argv(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(argv$LAYOUT, argv$OFFSET, fieldValue);
     }
-    public static void argv$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$0.const$2.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt allocated$LAYOUT = (OfInt)$LAYOUT.select(groupElement("allocated"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int allocated
+     * }
+     */
+    public static final OfInt allocated$layout() {
+        return allocated$LAYOUT;
     }
-    public static VarHandle allocated$VH() {
-        return constants$0.const$3;
+
+    private static final long allocated$OFFSET = 16;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int allocated
+     * }
+     */
+    public static final long allocated$offset() {
+        return allocated$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int allocated;
+     * {@snippet lang=c :
+     * int allocated
      * }
      */
-    public static int allocated$get(MemorySegment seg) {
-        return (int)constants$0.const$3.get(seg);
+    public static int allocated(MemorySegment struct) {
+        return struct.get(allocated$LAYOUT, allocated$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int allocated;
+     * {@snippet lang=c :
+     * int allocated
      * }
      */
-    public static void allocated$set(MemorySegment seg, int x) {
-        constants$0.const$3.set(seg, x);
+    public static void allocated(MemorySegment struct, int fieldValue) {
+        struct.set(allocated$LAYOUT, allocated$OFFSET, fieldValue);
     }
-    public static int allocated$get(MemorySegment seg, long index) {
-        return (int)constants$0.const$3.get(seg.asSlice(index*sizeof()));
+
+    /**
+     * Obtains a slice of {@code arrayParam} which selects the array element at {@code index}.
+     * The returned segment has address {@code arrayParam.address() + index * layout().byteSize()}
+     */
+    public static MemorySegment asSlice(MemorySegment array, long index) {
+        return array.asSlice(layout().byteSize() * index);
     }
-    public static void allocated$set(MemorySegment seg, long index, int x) {
-        constants$0.const$3.set(seg.asSlice(index*sizeof()), x);
+
+    /**
+     * The size (in bytes) of this struct
+     */
+    public static long sizeof() { return layout().byteSize(); }
+
+    /**
+     * Allocate a segment of size {@code layout().byteSize()} using {@code allocator}
+     */
+    public static MemorySegment allocate(SegmentAllocator allocator) {
+        return allocator.allocate(layout());
     }
-    public static long sizeof() { return $LAYOUT().byteSize(); }
-    public static MemorySegment allocate(SegmentAllocator allocator) { return allocator.allocate($LAYOUT()); }
-    public static MemorySegment allocateArray(long len, SegmentAllocator allocator) {
-        return allocator.allocate(MemoryLayout.sequenceLayout(len, $LAYOUT()));
+
+    /**
+     * Allocate an array of size {@code elementCount} using {@code allocator}.
+     * The returned segment has size {@code elementCount * layout().byteSize()}.
+     */
+    public static MemorySegment allocateArray(long elementCount, SegmentAllocator allocator) {
+        return allocator.allocate(MemoryLayout.sequenceLayout(elementCount, layout()));
     }
-    public static MemorySegment ofAddress(MemorySegment addr, Arena scope) { return RuntimeHelper.asArray(addr, $LAYOUT(), 1, scope); }
-}
 
+    /**
+     * Reinterprets {@code addr} using target {@code arena} and {@code cleanupAction) (if any).
+     * The returned segment has size {@code layout().byteSize()}
+     */
+    public static MemorySegment reinterpret(MemorySegment addr, Arena arena, Consumer<MemorySegment> cleanup) {
+        return reinterpret(addr, 1, arena, cleanup);
+    }
+
+    /**
+     * Reinterprets {@code addr} using target {@code arena} and {@code cleanupAction) (if any).
+     * The returned segment has size {@code elementCount * layout().byteSize()}
+     */
+    public static MemorySegment reinterpret(MemorySegment addr, long elementCount, Arena arena, Consumer<MemorySegment> cleanup) {
+        return addr.reinterpret(layout().byteSize() * elementCount, arena, cleanup);
+    }
+}
 
diff --git a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/RuntimeHelper.java b/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/RuntimeHelper.java
deleted file mode 100644
index 6fce6ccb..00000000
--- a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/RuntimeHelper.java
+++ /dev/null
@@ -1,245 +0,0 @@
-package org.cryptomator.jfuse.win.extr.fuse3;
-// Generated by jextract
-
-import java.lang.foreign.Linker;
-import java.lang.foreign.FunctionDescriptor;
-import java.lang.foreign.GroupLayout;
-import java.lang.foreign.SymbolLookup;
-import java.lang.foreign.MemoryLayout;
-import java.lang.foreign.MemorySegment;
-import java.lang.foreign.Arena;
-import java.lang.foreign.SegmentAllocator;
-import java.lang.foreign.ValueLayout;
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.MethodHandles;
-import java.lang.invoke.MethodType;
-import java.io.File;
-import java.nio.file.Path;
-import java.nio.charset.StandardCharsets;
-import java.util.Arrays;
-import java.util.Optional;
-import java.util.stream.Stream;
-
-import java.lang.foreign.AddressLayout;
-import java.lang.foreign.MemoryLayout;
-
-import static java.lang.foreign.Linker.*;
-import static java.lang.foreign.ValueLayout.*;
-
-final class RuntimeHelper {
-
-    private static final Linker LINKER = Linker.nativeLinker();
-    private static final ClassLoader LOADER = RuntimeHelper.class.getClassLoader();
-    private static final MethodHandles.Lookup MH_LOOKUP = MethodHandles.lookup();
-    private static final SymbolLookup SYMBOL_LOOKUP;
-    private static final SegmentAllocator THROWING_ALLOCATOR = (x, y) -> { throw new AssertionError("should not reach here"); };
-    static final AddressLayout POINTER = ValueLayout.ADDRESS.withTargetLayout(MemoryLayout.sequenceLayout(JAVA_BYTE));
-
-    final static SegmentAllocator CONSTANT_ALLOCATOR =
-            (size, align) -> Arena.ofAuto().allocate(size, align);
-
-    static {
-        
-        SymbolLookup loaderLookup = SymbolLookup.loaderLookup();
-        SYMBOL_LOOKUP = name -> loaderLookup.find(name).or(() -> LINKER.defaultLookup().find(name));
-    }
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private RuntimeHelper() {}
-
-    static <T> T requireNonNull(T obj, String symbolName) {
-        if (obj == null) {
-            throw new UnsatisfiedLinkError("unresolved symbol: " + symbolName);
-        }
-        return obj;
-    }
-
-    static MemorySegment lookupGlobalVariable(String name, MemoryLayout layout) {
-        return SYMBOL_LOOKUP.find(name)
-                .map(s -> s.reinterpret(layout.byteSize()))
-                .orElse(null);
-    }
-
-    static MethodHandle downcallHandle(String name, FunctionDescriptor fdesc) {
-        return SYMBOL_LOOKUP.find(name).
-                map(addr -> LINKER.downcallHandle(addr, fdesc)).
-                orElse(null);
-    }
-
-    static MethodHandle downcallHandle(FunctionDescriptor fdesc) {
-        return LINKER.downcallHandle(fdesc);
-    }
-
-    static MethodHandle downcallHandleVariadic(String name, FunctionDescriptor fdesc) {
-        return SYMBOL_LOOKUP.find(name).
-                map(addr -> VarargsInvoker.make(addr, fdesc)).
-                orElse(null);
-    }
-
-    static MethodHandle upcallHandle(Class<?> fi, String name, FunctionDescriptor fdesc) {
-        try {
-            return MH_LOOKUP.findVirtual(fi, name, fdesc.toMethodType());
-        } catch (Throwable ex) {
-            throw new AssertionError(ex);
-        }
-    }
-
-    static <Z> MemorySegment upcallStub(MethodHandle fiHandle, Z z, FunctionDescriptor fdesc, Arena scope) {
-        try {
-            fiHandle = fiHandle.bindTo(z);
-            return LINKER.upcallStub(fiHandle, fdesc, scope);
-        } catch (Throwable ex) {
-            throw new AssertionError(ex);
-        }
-    }
-
-    static MemorySegment asArray(MemorySegment addr, MemoryLayout layout, int numElements, Arena arena) {
-         return addr.reinterpret(numElements * layout.byteSize(), arena, null);
-    }
-
-    // Internals only below this point
-
-    private static final class VarargsInvoker {
-        private static final MethodHandle INVOKE_MH;
-        private final MemorySegment symbol;
-        private final FunctionDescriptor function;
-
-        private VarargsInvoker(MemorySegment symbol, FunctionDescriptor function) {
-            this.symbol = symbol;
-            this.function = function;
-        }
-
-        static {
-            try {
-                INVOKE_MH = MethodHandles.lookup().findVirtual(VarargsInvoker.class, "invoke", MethodType.methodType(Object.class, SegmentAllocator.class, Object[].class));
-            } catch (ReflectiveOperationException e) {
-                throw new RuntimeException(e);
-            }
-        }
-
-        static MethodHandle make(MemorySegment symbol, FunctionDescriptor function) {
-            VarargsInvoker invoker = new VarargsInvoker(symbol, function);
-            MethodHandle handle = INVOKE_MH.bindTo(invoker).asCollector(Object[].class, function.argumentLayouts().size() + 1);
-            MethodType mtype = MethodType.methodType(function.returnLayout().isPresent() ? carrier(function.returnLayout().get(), true) : void.class);
-            for (MemoryLayout layout : function.argumentLayouts()) {
-                mtype = mtype.appendParameterTypes(carrier(layout, false));
-            }
-            mtype = mtype.appendParameterTypes(Object[].class);
-            boolean needsAllocator = function.returnLayout().isPresent() &&
-                                function.returnLayout().get() instanceof GroupLayout;
-            if (needsAllocator) {
-                mtype = mtype.insertParameterTypes(0, SegmentAllocator.class);
-            } else {
-                handle = MethodHandles.insertArguments(handle, 0, THROWING_ALLOCATOR);
-            }
-            return handle.asType(mtype);
-        }
-
-        static Class<?> carrier(MemoryLayout layout, boolean ret) {
-            if (layout instanceof ValueLayout valueLayout) {
-                return valueLayout.carrier();
-            } else if (layout instanceof GroupLayout) {
-                return MemorySegment.class;
-            } else {
-                throw new AssertionError("Cannot get here!");
-            }
-        }
-
-        private Object invoke(SegmentAllocator allocator, Object[] args) throws Throwable {
-            // one trailing Object[]
-            int nNamedArgs = function.argumentLayouts().size();
-            assert(args.length == nNamedArgs + 1);
-            // The last argument is the array of vararg collector
-            Object[] unnamedArgs = (Object[]) args[args.length - 1];
-
-            int argsCount = nNamedArgs + unnamedArgs.length;
-            Class<?>[] argTypes = new Class<?>[argsCount];
-            MemoryLayout[] argLayouts = new MemoryLayout[nNamedArgs + unnamedArgs.length];
-
-            int pos = 0;
-            for (pos = 0; pos < nNamedArgs; pos++) {
-                argLayouts[pos] = function.argumentLayouts().get(pos);
-            }
-
-            assert pos == nNamedArgs;
-            for (Object o: unnamedArgs) {
-                argLayouts[pos] = variadicLayout(normalize(o.getClass()));
-                pos++;
-            }
-            assert pos == argsCount;
-
-            FunctionDescriptor f = (function.returnLayout().isEmpty()) ?
-                    FunctionDescriptor.ofVoid(argLayouts) :
-                    FunctionDescriptor.of(function.returnLayout().get(), argLayouts);
-            MethodHandle mh = LINKER.downcallHandle(symbol, f);
-            boolean needsAllocator = function.returnLayout().isPresent() &&
-                                            function.returnLayout().get() instanceof GroupLayout;
-            if (needsAllocator) {
-                mh = mh.bindTo(allocator);
-            }
-            // flatten argument list so that it can be passed to an asSpreader MH
-            Object[] allArgs = new Object[nNamedArgs + unnamedArgs.length];
-            System.arraycopy(args, 0, allArgs, 0, nNamedArgs);
-            System.arraycopy(unnamedArgs, 0, allArgs, nNamedArgs, unnamedArgs.length);
-
-            return mh.asSpreader(Object[].class, argsCount).invoke(allArgs);
-        }
-
-        private static Class<?> unboxIfNeeded(Class<?> clazz) {
-            if (clazz == Boolean.class) {
-                return boolean.class;
-            } else if (clazz == Void.class) {
-                return void.class;
-            } else if (clazz == Byte.class) {
-                return byte.class;
-            } else if (clazz == Character.class) {
-                return char.class;
-            } else if (clazz == Short.class) {
-                return short.class;
-            } else if (clazz == Integer.class) {
-                return int.class;
-            } else if (clazz == Long.class) {
-                return long.class;
-            } else if (clazz == Float.class) {
-                return float.class;
-            } else if (clazz == Double.class) {
-                return double.class;
-            } else {
-                return clazz;
-            }
-        }
-
-        private Class<?> promote(Class<?> c) {
-            if (c == byte.class || c == char.class || c == short.class || c == int.class) {
-                return long.class;
-            } else if (c == float.class) {
-                return double.class;
-            } else {
-                return c;
-            }
-        }
-
-        private Class<?> normalize(Class<?> c) {
-            c = unboxIfNeeded(c);
-            if (c.isPrimitive()) {
-                return promote(c);
-            }
-            if (c == MemorySegment.class) {
-                return MemorySegment.class;
-            }
-            throw new IllegalArgumentException("Invalid type for ABI: " + c.getTypeName());
-        }
-
-        private MemoryLayout variadicLayout(Class<?> c) {
-            if (c == long.class) {
-                return JAVA_LONG;
-            } else if (c == double.class) {
-                return JAVA_DOUBLE;
-            } else if (c == MemorySegment.class) {
-                return ADDRESS;
-            } else {
-                throw new IllegalArgumentException("Unhandled variadic argument class: " + c);
-            }
-        }
-    }
-}
diff --git a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/constants$0.java b/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/constants$0.java
deleted file mode 100644
index c917deb1..00000000
--- a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/constants$0.java
+++ /dev/null
@@ -1,56 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.win.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$0 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$0() {}
-    static final StructLayout const$0 = MemoryLayout.structLayout(
-        JAVA_LONG.withName("tv_sec"),
-        JAVA_LONG.withName("tv_nsec")
-    ).withName("fuse_timespec");
-    static final VarHandle const$1 = constants$0.const$0.varHandle(MemoryLayout.PathElement.groupElement("tv_sec"));
-    static final VarHandle const$2 = constants$0.const$0.varHandle(MemoryLayout.PathElement.groupElement("tv_nsec"));
-    static final StructLayout const$3 = MemoryLayout.structLayout(
-        JAVA_INT.withName("st_dev"),
-        MemoryLayout.paddingLayout(4),
-        JAVA_LONG.withName("st_ino"),
-        JAVA_INT.withName("st_mode"),
-        JAVA_SHORT.withName("st_nlink"),
-        MemoryLayout.paddingLayout(2),
-        JAVA_INT.withName("st_uid"),
-        JAVA_INT.withName("st_gid"),
-        JAVA_INT.withName("st_rdev"),
-        MemoryLayout.paddingLayout(4),
-        JAVA_LONG.withName("st_size"),
-        MemoryLayout.structLayout(
-            JAVA_LONG.withName("tv_sec"),
-            JAVA_LONG.withName("tv_nsec")
-        ).withName("st_atim"),
-        MemoryLayout.structLayout(
-            JAVA_LONG.withName("tv_sec"),
-            JAVA_LONG.withName("tv_nsec")
-        ).withName("st_mtim"),
-        MemoryLayout.structLayout(
-            JAVA_LONG.withName("tv_sec"),
-            JAVA_LONG.withName("tv_nsec")
-        ).withName("st_ctim"),
-        JAVA_INT.withName("st_blksize"),
-        MemoryLayout.paddingLayout(4),
-        JAVA_LONG.withName("st_blocks"),
-        MemoryLayout.structLayout(
-            JAVA_LONG.withName("tv_sec"),
-            JAVA_LONG.withName("tv_nsec")
-        ).withName("st_birthtim")
-    ).withName("fuse_stat");
-    static final VarHandle const$4 = constants$0.const$3.varHandle(MemoryLayout.PathElement.groupElement("st_dev"));
-    static final VarHandle const$5 = constants$0.const$3.varHandle(MemoryLayout.PathElement.groupElement("st_ino"));
-}
-
-
diff --git a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/constants$1.java b/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/constants$1.java
deleted file mode 100644
index 59f2ac2a..00000000
--- a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/constants$1.java
+++ /dev/null
@@ -1,22 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.win.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$1 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$1() {}
-    static final VarHandle const$0 = constants$0.const$3.varHandle(MemoryLayout.PathElement.groupElement("st_mode"));
-    static final VarHandle const$1 = constants$0.const$3.varHandle(MemoryLayout.PathElement.groupElement("st_nlink"));
-    static final VarHandle const$2 = constants$0.const$3.varHandle(MemoryLayout.PathElement.groupElement("st_uid"));
-    static final VarHandle const$3 = constants$0.const$3.varHandle(MemoryLayout.PathElement.groupElement("st_gid"));
-    static final VarHandle const$4 = constants$0.const$3.varHandle(MemoryLayout.PathElement.groupElement("st_rdev"));
-    static final VarHandle const$5 = constants$0.const$3.varHandle(MemoryLayout.PathElement.groupElement("st_size"));
-}
-
-
diff --git a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/constants$10.java b/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/constants$10.java
deleted file mode 100644
index 7012b3c4..00000000
--- a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/constants$10.java
+++ /dev/null
@@ -1,22 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.win.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$10 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$10() {}
-    static final VarHandle const$0 = constants$8.const$0.varHandle(MemoryLayout.PathElement.groupElement("remember"));
-    static final VarHandle const$1 = constants$8.const$0.varHandle(MemoryLayout.PathElement.groupElement("hard_remove"));
-    static final VarHandle const$2 = constants$8.const$0.varHandle(MemoryLayout.PathElement.groupElement("use_ino"));
-    static final VarHandle const$3 = constants$8.const$0.varHandle(MemoryLayout.PathElement.groupElement("readdir_ino"));
-    static final VarHandle const$4 = constants$8.const$0.varHandle(MemoryLayout.PathElement.groupElement("direct_io"));
-    static final VarHandle const$5 = constants$8.const$0.varHandle(MemoryLayout.PathElement.groupElement("kernel_cache"));
-}
-
-
diff --git a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/constants$11.java b/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/constants$11.java
deleted file mode 100644
index 9019b7df..00000000
--- a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/constants$11.java
+++ /dev/null
@@ -1,22 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.win.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$11 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$11() {}
-    static final VarHandle const$0 = constants$8.const$0.varHandle(MemoryLayout.PathElement.groupElement("auto_cache"));
-    static final VarHandle const$1 = constants$8.const$0.varHandle(MemoryLayout.PathElement.groupElement("ac_attr_timeout_set"));
-    static final VarHandle const$2 = constants$8.const$0.varHandle(MemoryLayout.PathElement.groupElement("ac_attr_timeout"));
-    static final VarHandle const$3 = constants$8.const$0.varHandle(MemoryLayout.PathElement.groupElement("nullpath_ok"));
-    static final VarHandle const$4 = constants$8.const$0.varHandle(MemoryLayout.PathElement.groupElement("show_help"));
-    static final VarHandle const$5 = constants$8.const$0.varHandle(MemoryLayout.PathElement.groupElement("modules"));
-}
-
-
diff --git a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/constants$12.java b/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/constants$12.java
deleted file mode 100644
index 3ccf0b5a..00000000
--- a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/constants$12.java
+++ /dev/null
@@ -1,69 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.win.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$12 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$12() {}
-    static final VarHandle const$0 = constants$8.const$0.varHandle(MemoryLayout.PathElement.groupElement("debug"));
-    static final StructLayout const$1 = MemoryLayout.structLayout(
-        RuntimeHelper.POINTER.withName("getattr"),
-        RuntimeHelper.POINTER.withName("readlink"),
-        RuntimeHelper.POINTER.withName("mknod"),
-        RuntimeHelper.POINTER.withName("mkdir"),
-        RuntimeHelper.POINTER.withName("unlink"),
-        RuntimeHelper.POINTER.withName("rmdir"),
-        RuntimeHelper.POINTER.withName("symlink"),
-        RuntimeHelper.POINTER.withName("rename"),
-        RuntimeHelper.POINTER.withName("link"),
-        RuntimeHelper.POINTER.withName("chmod"),
-        RuntimeHelper.POINTER.withName("chown"),
-        RuntimeHelper.POINTER.withName("truncate"),
-        RuntimeHelper.POINTER.withName("open"),
-        RuntimeHelper.POINTER.withName("read"),
-        RuntimeHelper.POINTER.withName("write"),
-        RuntimeHelper.POINTER.withName("statfs"),
-        RuntimeHelper.POINTER.withName("flush"),
-        RuntimeHelper.POINTER.withName("release"),
-        RuntimeHelper.POINTER.withName("fsync"),
-        RuntimeHelper.POINTER.withName("setxattr"),
-        RuntimeHelper.POINTER.withName("getxattr"),
-        RuntimeHelper.POINTER.withName("listxattr"),
-        RuntimeHelper.POINTER.withName("removexattr"),
-        RuntimeHelper.POINTER.withName("opendir"),
-        RuntimeHelper.POINTER.withName("readdir"),
-        RuntimeHelper.POINTER.withName("releasedir"),
-        RuntimeHelper.POINTER.withName("fsyncdir"),
-        RuntimeHelper.POINTER.withName("init"),
-        RuntimeHelper.POINTER.withName("destroy"),
-        RuntimeHelper.POINTER.withName("access"),
-        RuntimeHelper.POINTER.withName("create"),
-        RuntimeHelper.POINTER.withName("lock"),
-        RuntimeHelper.POINTER.withName("utimens"),
-        RuntimeHelper.POINTER.withName("bmap"),
-        RuntimeHelper.POINTER.withName("ioctl"),
-        RuntimeHelper.POINTER.withName("poll"),
-        RuntimeHelper.POINTER.withName("write_buf"),
-        RuntimeHelper.POINTER.withName("read_buf"),
-        RuntimeHelper.POINTER.withName("flock"),
-        RuntimeHelper.POINTER.withName("fallocate")
-    ).withName("fuse3_operations");
-    static final FunctionDescriptor const$2 = FunctionDescriptor.of(JAVA_INT,
-        RuntimeHelper.POINTER,
-        RuntimeHelper.POINTER,
-        RuntimeHelper.POINTER
-    );
-    static final MethodHandle const$3 = RuntimeHelper.upcallHandle(fuse3_operations.getattr.class, "apply", constants$12.const$2);
-    static final MethodHandle const$4 = RuntimeHelper.downcallHandle(
-        constants$12.const$2
-    );
-    static final VarHandle const$5 = constants$12.const$1.varHandle(MemoryLayout.PathElement.groupElement("getattr"));
-}
-
-
diff --git a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/constants$13.java b/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/constants$13.java
deleted file mode 100644
index f4eac9b9..00000000
--- a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/constants$13.java
+++ /dev/null
@@ -1,32 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.win.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$13 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$13() {}
-    static final FunctionDescriptor const$0 = FunctionDescriptor.of(JAVA_INT,
-        RuntimeHelper.POINTER,
-        RuntimeHelper.POINTER,
-        JAVA_LONG
-    );
-    static final MethodHandle const$1 = RuntimeHelper.upcallHandle(fuse3_operations.readlink.class, "apply", constants$13.const$0);
-    static final MethodHandle const$2 = RuntimeHelper.downcallHandle(
-        constants$13.const$0
-    );
-    static final VarHandle const$3 = constants$12.const$1.varHandle(MemoryLayout.PathElement.groupElement("readlink"));
-    static final FunctionDescriptor const$4 = FunctionDescriptor.of(JAVA_INT,
-        RuntimeHelper.POINTER,
-        JAVA_INT,
-        JAVA_INT
-    );
-    static final MethodHandle const$5 = RuntimeHelper.upcallHandle(fuse3_operations.mknod.class, "apply", constants$13.const$4);
-}
-
-
diff --git a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/constants$14.java b/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/constants$14.java
deleted file mode 100644
index 631a1716..00000000
--- a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/constants$14.java
+++ /dev/null
@@ -1,29 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.win.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$14 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$14() {}
-    static final MethodHandle const$0 = RuntimeHelper.downcallHandle(
-        constants$13.const$4
-    );
-    static final VarHandle const$1 = constants$12.const$1.varHandle(MemoryLayout.PathElement.groupElement("mknod"));
-    static final FunctionDescriptor const$2 = FunctionDescriptor.of(JAVA_INT,
-        RuntimeHelper.POINTER,
-        JAVA_INT
-    );
-    static final MethodHandle const$3 = RuntimeHelper.upcallHandle(fuse3_operations.mkdir.class, "apply", constants$14.const$2);
-    static final MethodHandle const$4 = RuntimeHelper.downcallHandle(
-        constants$14.const$2
-    );
-    static final VarHandle const$5 = constants$12.const$1.varHandle(MemoryLayout.PathElement.groupElement("mkdir"));
-}
-
-
diff --git a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/constants$15.java b/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/constants$15.java
deleted file mode 100644
index edca9f35..00000000
--- a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/constants$15.java
+++ /dev/null
@@ -1,26 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.win.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$15 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$15() {}
-    static final FunctionDescriptor const$0 = FunctionDescriptor.of(JAVA_INT,
-        RuntimeHelper.POINTER
-    );
-    static final MethodHandle const$1 = RuntimeHelper.upcallHandle(fuse3_operations.unlink.class, "apply", constants$15.const$0);
-    static final MethodHandle const$2 = RuntimeHelper.downcallHandle(
-        constants$15.const$0
-    );
-    static final VarHandle const$3 = constants$12.const$1.varHandle(MemoryLayout.PathElement.groupElement("unlink"));
-    static final MethodHandle const$4 = RuntimeHelper.upcallHandle(fuse3_operations.rmdir.class, "apply", constants$15.const$0);
-    static final VarHandle const$5 = constants$12.const$1.varHandle(MemoryLayout.PathElement.groupElement("rmdir"));
-}
-
-
diff --git a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/constants$16.java b/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/constants$16.java
deleted file mode 100644
index ae57ed39..00000000
--- a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/constants$16.java
+++ /dev/null
@@ -1,31 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.win.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$16 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$16() {}
-    static final FunctionDescriptor const$0 = FunctionDescriptor.of(JAVA_INT,
-        RuntimeHelper.POINTER,
-        RuntimeHelper.POINTER
-    );
-    static final MethodHandle const$1 = RuntimeHelper.upcallHandle(fuse3_operations.symlink.class, "apply", constants$16.const$0);
-    static final MethodHandle const$2 = RuntimeHelper.downcallHandle(
-        constants$16.const$0
-    );
-    static final VarHandle const$3 = constants$12.const$1.varHandle(MemoryLayout.PathElement.groupElement("symlink"));
-    static final FunctionDescriptor const$4 = FunctionDescriptor.of(JAVA_INT,
-        RuntimeHelper.POINTER,
-        RuntimeHelper.POINTER,
-        JAVA_INT
-    );
-    static final MethodHandle const$5 = RuntimeHelper.upcallHandle(fuse3_operations.rename.class, "apply", constants$16.const$4);
-}
-
-
diff --git a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/constants$17.java b/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/constants$17.java
deleted file mode 100644
index fd5a5f73..00000000
--- a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/constants$17.java
+++ /dev/null
@@ -1,28 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.win.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$17 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$17() {}
-    static final MethodHandle const$0 = RuntimeHelper.downcallHandle(
-        constants$16.const$4
-    );
-    static final VarHandle const$1 = constants$12.const$1.varHandle(MemoryLayout.PathElement.groupElement("rename"));
-    static final MethodHandle const$2 = RuntimeHelper.upcallHandle(fuse3_operations.link.class, "apply", constants$16.const$0);
-    static final VarHandle const$3 = constants$12.const$1.varHandle(MemoryLayout.PathElement.groupElement("link"));
-    static final FunctionDescriptor const$4 = FunctionDescriptor.of(JAVA_INT,
-        RuntimeHelper.POINTER,
-        JAVA_INT,
-        RuntimeHelper.POINTER
-    );
-    static final MethodHandle const$5 = RuntimeHelper.upcallHandle(fuse3_operations.chmod.class, "apply", constants$17.const$4);
-}
-
-
diff --git a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/constants$18.java b/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/constants$18.java
deleted file mode 100644
index adf93c44..00000000
--- a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/constants$18.java
+++ /dev/null
@@ -1,31 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.win.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$18 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$18() {}
-    static final MethodHandle const$0 = RuntimeHelper.downcallHandle(
-        constants$17.const$4
-    );
-    static final VarHandle const$1 = constants$12.const$1.varHandle(MemoryLayout.PathElement.groupElement("chmod"));
-    static final FunctionDescriptor const$2 = FunctionDescriptor.of(JAVA_INT,
-        RuntimeHelper.POINTER,
-        JAVA_INT,
-        JAVA_INT,
-        RuntimeHelper.POINTER
-    );
-    static final MethodHandle const$3 = RuntimeHelper.upcallHandle(fuse3_operations.chown.class, "apply", constants$18.const$2);
-    static final MethodHandle const$4 = RuntimeHelper.downcallHandle(
-        constants$18.const$2
-    );
-    static final VarHandle const$5 = constants$12.const$1.varHandle(MemoryLayout.PathElement.groupElement("chown"));
-}
-
-
diff --git a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/constants$19.java b/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/constants$19.java
deleted file mode 100644
index 9b083c2e..00000000
--- a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/constants$19.java
+++ /dev/null
@@ -1,28 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.win.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$19 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$19() {}
-    static final FunctionDescriptor const$0 = FunctionDescriptor.of(JAVA_INT,
-        RuntimeHelper.POINTER,
-        JAVA_LONG,
-        RuntimeHelper.POINTER
-    );
-    static final MethodHandle const$1 = RuntimeHelper.upcallHandle(fuse3_operations.truncate.class, "apply", constants$19.const$0);
-    static final MethodHandle const$2 = RuntimeHelper.downcallHandle(
-        constants$19.const$0
-    );
-    static final VarHandle const$3 = constants$12.const$1.varHandle(MemoryLayout.PathElement.groupElement("truncate"));
-    static final MethodHandle const$4 = RuntimeHelper.upcallHandle(fuse3_operations.open.class, "apply", constants$16.const$0);
-    static final VarHandle const$5 = constants$12.const$1.varHandle(MemoryLayout.PathElement.groupElement("open"));
-}
-
-
diff --git a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/constants$2.java b/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/constants$2.java
deleted file mode 100644
index 6198d365..00000000
--- a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/constants$2.java
+++ /dev/null
@@ -1,34 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.win.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$2 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$2() {}
-    static final VarHandle const$0 = constants$0.const$3.varHandle(MemoryLayout.PathElement.groupElement("st_blksize"));
-    static final VarHandle const$1 = constants$0.const$3.varHandle(MemoryLayout.PathElement.groupElement("st_blocks"));
-    static final StructLayout const$2 = MemoryLayout.structLayout(
-        JAVA_LONG.withName("f_bsize"),
-        JAVA_LONG.withName("f_frsize"),
-        JAVA_LONG.withName("f_blocks"),
-        JAVA_LONG.withName("f_bfree"),
-        JAVA_LONG.withName("f_bavail"),
-        JAVA_LONG.withName("f_files"),
-        JAVA_LONG.withName("f_ffree"),
-        JAVA_LONG.withName("f_favail"),
-        JAVA_LONG.withName("f_fsid"),
-        JAVA_LONG.withName("f_flag"),
-        JAVA_LONG.withName("f_namemax")
-    ).withName("fuse_statvfs");
-    static final VarHandle const$3 = constants$2.const$2.varHandle(MemoryLayout.PathElement.groupElement("f_bsize"));
-    static final VarHandle const$4 = constants$2.const$2.varHandle(MemoryLayout.PathElement.groupElement("f_frsize"));
-    static final VarHandle const$5 = constants$2.const$2.varHandle(MemoryLayout.PathElement.groupElement("f_blocks"));
-}
-
-
diff --git a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/constants$20.java b/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/constants$20.java
deleted file mode 100644
index 38cc1a2b..00000000
--- a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/constants$20.java
+++ /dev/null
@@ -1,30 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.win.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$20 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$20() {}
-    static final FunctionDescriptor const$0 = FunctionDescriptor.of(JAVA_INT,
-        RuntimeHelper.POINTER,
-        RuntimeHelper.POINTER,
-        JAVA_LONG,
-        JAVA_LONG,
-        RuntimeHelper.POINTER
-    );
-    static final MethodHandle const$1 = RuntimeHelper.upcallHandle(fuse3_operations.read.class, "apply", constants$20.const$0);
-    static final MethodHandle const$2 = RuntimeHelper.downcallHandle(
-        constants$20.const$0
-    );
-    static final VarHandle const$3 = constants$12.const$1.varHandle(MemoryLayout.PathElement.groupElement("read"));
-    static final MethodHandle const$4 = RuntimeHelper.upcallHandle(fuse3_operations.write.class, "apply", constants$20.const$0);
-    static final VarHandle const$5 = constants$12.const$1.varHandle(MemoryLayout.PathElement.groupElement("write"));
-}
-
-
diff --git a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/constants$21.java b/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/constants$21.java
deleted file mode 100644
index e68ba792..00000000
--- a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/constants$21.java
+++ /dev/null
@@ -1,22 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.win.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$21 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$21() {}
-    static final MethodHandle const$0 = RuntimeHelper.upcallHandle(fuse3_operations.statfs.class, "apply", constants$16.const$0);
-    static final VarHandle const$1 = constants$12.const$1.varHandle(MemoryLayout.PathElement.groupElement("statfs"));
-    static final MethodHandle const$2 = RuntimeHelper.upcallHandle(fuse3_operations.flush.class, "apply", constants$16.const$0);
-    static final VarHandle const$3 = constants$12.const$1.varHandle(MemoryLayout.PathElement.groupElement("flush"));
-    static final MethodHandle const$4 = RuntimeHelper.upcallHandle(fuse3_operations.release.class, "apply", constants$16.const$0);
-    static final VarHandle const$5 = constants$12.const$1.varHandle(MemoryLayout.PathElement.groupElement("release"));
-}
-
-
diff --git a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/constants$22.java b/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/constants$22.java
deleted file mode 100644
index 7908c0ee..00000000
--- a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/constants$22.java
+++ /dev/null
@@ -1,27 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.win.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$22 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$22() {}
-    static final MethodHandle const$0 = RuntimeHelper.upcallHandle(fuse3_operations.fsync.class, "apply", constants$17.const$4);
-    static final VarHandle const$1 = constants$12.const$1.varHandle(MemoryLayout.PathElement.groupElement("fsync"));
-    static final MethodHandle const$2 = RuntimeHelper.upcallHandle(fuse3_operations.setxattr.class, "apply", constants$7.const$3);
-    static final VarHandle const$3 = constants$12.const$1.varHandle(MemoryLayout.PathElement.groupElement("setxattr"));
-    static final FunctionDescriptor const$4 = FunctionDescriptor.of(JAVA_INT,
-        RuntimeHelper.POINTER,
-        RuntimeHelper.POINTER,
-        RuntimeHelper.POINTER,
-        JAVA_LONG
-    );
-    static final MethodHandle const$5 = RuntimeHelper.upcallHandle(fuse3_operations.getxattr.class, "apply", constants$22.const$4);
-}
-
-
diff --git a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/constants$23.java b/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/constants$23.java
deleted file mode 100644
index f9966217..00000000
--- a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/constants$23.java
+++ /dev/null
@@ -1,24 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.win.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$23 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$23() {}
-    static final MethodHandle const$0 = RuntimeHelper.downcallHandle(
-        constants$22.const$4
-    );
-    static final VarHandle const$1 = constants$12.const$1.varHandle(MemoryLayout.PathElement.groupElement("getxattr"));
-    static final MethodHandle const$2 = RuntimeHelper.upcallHandle(fuse3_operations.listxattr.class, "apply", constants$13.const$0);
-    static final VarHandle const$3 = constants$12.const$1.varHandle(MemoryLayout.PathElement.groupElement("listxattr"));
-    static final MethodHandle const$4 = RuntimeHelper.upcallHandle(fuse3_operations.removexattr.class, "apply", constants$16.const$0);
-    static final VarHandle const$5 = constants$12.const$1.varHandle(MemoryLayout.PathElement.groupElement("removexattr"));
-}
-
-
diff --git a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/constants$24.java b/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/constants$24.java
deleted file mode 100644
index b08fa797..00000000
--- a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/constants$24.java
+++ /dev/null
@@ -1,31 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.win.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$24 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$24() {}
-    static final MethodHandle const$0 = RuntimeHelper.upcallHandle(fuse3_operations.opendir.class, "apply", constants$16.const$0);
-    static final VarHandle const$1 = constants$12.const$1.varHandle(MemoryLayout.PathElement.groupElement("opendir"));
-    static final FunctionDescriptor const$2 = FunctionDescriptor.of(JAVA_INT,
-        RuntimeHelper.POINTER,
-        RuntimeHelper.POINTER,
-        RuntimeHelper.POINTER,
-        JAVA_LONG,
-        RuntimeHelper.POINTER,
-        JAVA_INT
-    );
-    static final MethodHandle const$3 = RuntimeHelper.upcallHandle(fuse3_operations.readdir.class, "apply", constants$24.const$2);
-    static final MethodHandle const$4 = RuntimeHelper.downcallHandle(
-        constants$24.const$2
-    );
-    static final VarHandle const$5 = constants$12.const$1.varHandle(MemoryLayout.PathElement.groupElement("readdir"));
-}
-
-
diff --git a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/constants$25.java b/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/constants$25.java
deleted file mode 100644
index 0da655e0..00000000
--- a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/constants$25.java
+++ /dev/null
@@ -1,25 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.win.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$25 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$25() {}
-    static final MethodHandle const$0 = RuntimeHelper.upcallHandle(fuse3_operations.releasedir.class, "apply", constants$16.const$0);
-    static final VarHandle const$1 = constants$12.const$1.varHandle(MemoryLayout.PathElement.groupElement("releasedir"));
-    static final MethodHandle const$2 = RuntimeHelper.upcallHandle(fuse3_operations.fsyncdir.class, "apply", constants$17.const$4);
-    static final VarHandle const$3 = constants$12.const$1.varHandle(MemoryLayout.PathElement.groupElement("fsyncdir"));
-    static final FunctionDescriptor const$4 = FunctionDescriptor.of(RuntimeHelper.POINTER,
-        RuntimeHelper.POINTER,
-        RuntimeHelper.POINTER
-    );
-    static final MethodHandle const$5 = RuntimeHelper.upcallHandle(fuse3_operations.init.class, "apply", constants$25.const$4);
-}
-
-
diff --git a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/constants$26.java b/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/constants$26.java
deleted file mode 100644
index 720b873c..00000000
--- a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/constants$26.java
+++ /dev/null
@@ -1,28 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.win.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$26 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$26() {}
-    static final MethodHandle const$0 = RuntimeHelper.downcallHandle(
-        constants$25.const$4
-    );
-    static final VarHandle const$1 = constants$12.const$1.varHandle(MemoryLayout.PathElement.groupElement("init"));
-    static final FunctionDescriptor const$2 = FunctionDescriptor.ofVoid(
-        RuntimeHelper.POINTER
-    );
-    static final MethodHandle const$3 = RuntimeHelper.upcallHandle(fuse3_operations.destroy.class, "apply", constants$26.const$2);
-    static final MethodHandle const$4 = RuntimeHelper.downcallHandle(
-        constants$26.const$2
-    );
-    static final VarHandle const$5 = constants$12.const$1.varHandle(MemoryLayout.PathElement.groupElement("destroy"));
-}
-
-
diff --git a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/constants$27.java b/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/constants$27.java
deleted file mode 100644
index 96e79866..00000000
--- a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/constants$27.java
+++ /dev/null
@@ -1,27 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.win.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$27 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$27() {}
-    static final MethodHandle const$0 = RuntimeHelper.upcallHandle(fuse3_operations.access.class, "apply", constants$14.const$2);
-    static final VarHandle const$1 = constants$12.const$1.varHandle(MemoryLayout.PathElement.groupElement("access"));
-    static final MethodHandle const$2 = RuntimeHelper.upcallHandle(fuse3_operations.create.class, "apply", constants$17.const$4);
-    static final VarHandle const$3 = constants$12.const$1.varHandle(MemoryLayout.PathElement.groupElement("create"));
-    static final FunctionDescriptor const$4 = FunctionDescriptor.of(JAVA_INT,
-        RuntimeHelper.POINTER,
-        RuntimeHelper.POINTER,
-        JAVA_INT,
-        RuntimeHelper.POINTER
-    );
-    static final MethodHandle const$5 = RuntimeHelper.upcallHandle(fuse3_operations.lock.class, "apply", constants$27.const$4);
-}
-
-
diff --git a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/constants$28.java b/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/constants$28.java
deleted file mode 100644
index da652dd3..00000000
--- a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/constants$28.java
+++ /dev/null
@@ -1,24 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.win.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$28 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$28() {}
-    static final MethodHandle const$0 = RuntimeHelper.downcallHandle(
-        constants$27.const$4
-    );
-    static final VarHandle const$1 = constants$12.const$1.varHandle(MemoryLayout.PathElement.groupElement("lock"));
-    static final MethodHandle const$2 = RuntimeHelper.upcallHandle(fuse3_operations.utimens.class, "apply", constants$12.const$2);
-    static final VarHandle const$3 = constants$12.const$1.varHandle(MemoryLayout.PathElement.groupElement("utimens"));
-    static final MethodHandle const$4 = RuntimeHelper.upcallHandle(fuse3_operations.bmap.class, "apply", constants$19.const$0);
-    static final VarHandle const$5 = constants$12.const$1.varHandle(MemoryLayout.PathElement.groupElement("bmap"));
-}
-
-
diff --git a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/constants$29.java b/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/constants$29.java
deleted file mode 100644
index c7b84668..00000000
--- a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/constants$29.java
+++ /dev/null
@@ -1,36 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.win.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$29 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$29() {}
-    static final FunctionDescriptor const$0 = FunctionDescriptor.of(JAVA_INT,
-        RuntimeHelper.POINTER,
-        JAVA_INT,
-        RuntimeHelper.POINTER,
-        RuntimeHelper.POINTER,
-        JAVA_INT,
-        RuntimeHelper.POINTER
-    );
-    static final MethodHandle const$1 = RuntimeHelper.upcallHandle(fuse3_operations.ioctl.class, "apply", constants$29.const$0);
-    static final MethodHandle const$2 = RuntimeHelper.downcallHandle(
-        constants$29.const$0
-    );
-    static final VarHandle const$3 = constants$12.const$1.varHandle(MemoryLayout.PathElement.groupElement("ioctl"));
-    static final FunctionDescriptor const$4 = FunctionDescriptor.of(JAVA_INT,
-        RuntimeHelper.POINTER,
-        RuntimeHelper.POINTER,
-        RuntimeHelper.POINTER,
-        RuntimeHelper.POINTER
-    );
-    static final MethodHandle const$5 = RuntimeHelper.upcallHandle(fuse3_operations.poll.class, "apply", constants$29.const$4);
-}
-
-
diff --git a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/constants$3.java b/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/constants$3.java
deleted file mode 100644
index d20a40fc..00000000
--- a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/constants$3.java
+++ /dev/null
@@ -1,22 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.win.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$3 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$3() {}
-    static final VarHandle const$0 = constants$2.const$2.varHandle(MemoryLayout.PathElement.groupElement("f_bfree"));
-    static final VarHandle const$1 = constants$2.const$2.varHandle(MemoryLayout.PathElement.groupElement("f_bavail"));
-    static final VarHandle const$2 = constants$2.const$2.varHandle(MemoryLayout.PathElement.groupElement("f_files"));
-    static final VarHandle const$3 = constants$2.const$2.varHandle(MemoryLayout.PathElement.groupElement("f_ffree"));
-    static final VarHandle const$4 = constants$2.const$2.varHandle(MemoryLayout.PathElement.groupElement("f_favail"));
-    static final VarHandle const$5 = constants$2.const$2.varHandle(MemoryLayout.PathElement.groupElement("f_fsid"));
-}
-
-
diff --git a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/constants$30.java b/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/constants$30.java
deleted file mode 100644
index eb44b840..00000000
--- a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/constants$30.java
+++ /dev/null
@@ -1,31 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.win.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$30 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$30() {}
-    static final MethodHandle const$0 = RuntimeHelper.downcallHandle(
-        constants$29.const$4
-    );
-    static final VarHandle const$1 = constants$12.const$1.varHandle(MemoryLayout.PathElement.groupElement("poll"));
-    static final FunctionDescriptor const$2 = FunctionDescriptor.of(JAVA_INT,
-        RuntimeHelper.POINTER,
-        RuntimeHelper.POINTER,
-        JAVA_LONG,
-        RuntimeHelper.POINTER
-    );
-    static final MethodHandle const$3 = RuntimeHelper.upcallHandle(fuse3_operations.write_buf.class, "apply", constants$30.const$2);
-    static final MethodHandle const$4 = RuntimeHelper.downcallHandle(
-        constants$30.const$2
-    );
-    static final VarHandle const$5 = constants$12.const$1.varHandle(MemoryLayout.PathElement.groupElement("write_buf"));
-}
-
-
diff --git a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/constants$31.java b/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/constants$31.java
deleted file mode 100644
index 8567f36b..00000000
--- a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/constants$31.java
+++ /dev/null
@@ -1,28 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.win.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$31 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$31() {}
-    static final MethodHandle const$0 = RuntimeHelper.upcallHandle(fuse3_operations.read_buf.class, "apply", constants$20.const$0);
-    static final VarHandle const$1 = constants$12.const$1.varHandle(MemoryLayout.PathElement.groupElement("read_buf"));
-    static final MethodHandle const$2 = RuntimeHelper.upcallHandle(fuse3_operations.flock.class, "apply", constants$16.const$4);
-    static final VarHandle const$3 = constants$12.const$1.varHandle(MemoryLayout.PathElement.groupElement("flock"));
-    static final FunctionDescriptor const$4 = FunctionDescriptor.of(JAVA_INT,
-        RuntimeHelper.POINTER,
-        JAVA_INT,
-        JAVA_LONG,
-        JAVA_LONG,
-        RuntimeHelper.POINTER
-    );
-    static final MethodHandle const$5 = RuntimeHelper.upcallHandle(fuse3_operations.fallocate.class, "apply", constants$31.const$4);
-}
-
-
diff --git a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/constants$32.java b/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/constants$32.java
deleted file mode 100644
index 42ad78ee..00000000
--- a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/constants$32.java
+++ /dev/null
@@ -1,38 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.win.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$32 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$32() {}
-    static final MethodHandle const$0 = RuntimeHelper.downcallHandle(
-        constants$31.const$4
-    );
-    static final VarHandle const$1 = constants$12.const$1.varHandle(MemoryLayout.PathElement.groupElement("fallocate"));
-    static final MethodHandle const$2 = RuntimeHelper.downcallHandle(
-        "fuse3_lib_help",
-        constants$26.const$2
-    );
-    static final FunctionDescriptor const$3 = FunctionDescriptor.of(RuntimeHelper.POINTER,
-        RuntimeHelper.POINTER,
-        RuntimeHelper.POINTER,
-        JAVA_LONG,
-        RuntimeHelper.POINTER
-    );
-    static final MethodHandle const$4 = RuntimeHelper.downcallHandle(
-        "fuse3_new",
-        constants$32.const$3
-    );
-    static final MethodHandle const$5 = RuntimeHelper.downcallHandle(
-        "fuse3_destroy",
-        constants$26.const$2
-    );
-}
-
-
diff --git a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/constants$33.java b/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/constants$33.java
deleted file mode 100644
index a70732d8..00000000
--- a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/constants$33.java
+++ /dev/null
@@ -1,43 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.win.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$33 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$33() {}
-    static final MethodHandle const$0 = RuntimeHelper.downcallHandle(
-        "fuse3_mount",
-        constants$16.const$0
-    );
-    static final MethodHandle const$1 = RuntimeHelper.downcallHandle(
-        "fuse3_unmount",
-        constants$26.const$2
-    );
-    static final MethodHandle const$2 = RuntimeHelper.downcallHandle(
-        "fuse3_loop",
-        constants$15.const$0
-    );
-    static final MethodHandle const$3 = RuntimeHelper.downcallHandle(
-        "fuse3_loop_mt_31",
-        constants$14.const$2
-    );
-    static final MethodHandle const$4 = RuntimeHelper.downcallHandle(
-        "fuse3_exit",
-        constants$26.const$2
-    );
-    static final FunctionDescriptor const$5 = FunctionDescriptor.of(RuntimeHelper.POINTER,
-        RuntimeHelper.POINTER
-    );
-    static final MethodHandle const$6 = RuntimeHelper.downcallHandle(
-        "fuse3_get_session",
-        constants$33.const$5
-    );
-}
-
-
diff --git a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/constants$4.java b/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/constants$4.java
deleted file mode 100644
index 9d07837d..00000000
--- a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/constants$4.java
+++ /dev/null
@@ -1,29 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.win.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$4 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$4() {}
-    static final VarHandle const$0 = constants$2.const$2.varHandle(MemoryLayout.PathElement.groupElement("f_flag"));
-    static final VarHandle const$1 = constants$2.const$2.varHandle(MemoryLayout.PathElement.groupElement("f_namemax"));
-    static final StructLayout const$2 = MemoryLayout.structLayout(
-        JAVA_INT.withName("flags"),
-        MemoryLayout.paddingLayout(12),
-        JAVA_LONG.withName("fh"),
-        JAVA_LONG.withName("lock_owner"),
-        JAVA_INT.withName("poll_events"),
-        MemoryLayout.paddingLayout(4)
-    ).withName("fuse3_file_info");
-    static final VarHandle const$3 = constants$4.const$2.varHandle(MemoryLayout.PathElement.groupElement("flags"));
-    static final VarHandle const$4 = constants$4.const$2.varHandle(MemoryLayout.PathElement.groupElement("fh"));
-    static final VarHandle const$5 = constants$4.const$2.varHandle(MemoryLayout.PathElement.groupElement("lock_owner"));
-}
-
-
diff --git a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/constants$5.java b/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/constants$5.java
deleted file mode 100644
index bcd3791d..00000000
--- a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/constants$5.java
+++ /dev/null
@@ -1,37 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.win.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$5 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$5() {}
-    static final VarHandle const$0 = constants$4.const$2.varHandle(MemoryLayout.PathElement.groupElement("poll_events"));
-    static final StructLayout const$1 = MemoryLayout.structLayout(
-        JAVA_INT.withName("clone_fd"),
-        JAVA_INT.withName("max_idle_threads")
-    ).withName("fuse3_loop_config");
-    static final VarHandle const$2 = constants$5.const$1.varHandle(MemoryLayout.PathElement.groupElement("clone_fd"));
-    static final VarHandle const$3 = constants$5.const$1.varHandle(MemoryLayout.PathElement.groupElement("max_idle_threads"));
-    static final StructLayout const$4 = MemoryLayout.structLayout(
-        JAVA_INT.withName("proto_major"),
-        JAVA_INT.withName("proto_minor"),
-        JAVA_INT.withName("max_write"),
-        JAVA_INT.withName("max_read"),
-        JAVA_INT.withName("max_readahead"),
-        JAVA_INT.withName("capable"),
-        JAVA_INT.withName("want"),
-        JAVA_INT.withName("max_background"),
-        JAVA_INT.withName("congestion_threshold"),
-        JAVA_INT.withName("time_gran"),
-        MemoryLayout.sequenceLayout(22, JAVA_INT).withName("reserved")
-    ).withName("fuse3_conn_info");
-    static final VarHandle const$5 = constants$5.const$4.varHandle(MemoryLayout.PathElement.groupElement("proto_major"));
-}
-
-
diff --git a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/constants$6.java b/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/constants$6.java
deleted file mode 100644
index 12634927..00000000
--- a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/constants$6.java
+++ /dev/null
@@ -1,22 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.win.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$6 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$6() {}
-    static final VarHandle const$0 = constants$5.const$4.varHandle(MemoryLayout.PathElement.groupElement("proto_minor"));
-    static final VarHandle const$1 = constants$5.const$4.varHandle(MemoryLayout.PathElement.groupElement("max_write"));
-    static final VarHandle const$2 = constants$5.const$4.varHandle(MemoryLayout.PathElement.groupElement("max_read"));
-    static final VarHandle const$3 = constants$5.const$4.varHandle(MemoryLayout.PathElement.groupElement("max_readahead"));
-    static final VarHandle const$4 = constants$5.const$4.varHandle(MemoryLayout.PathElement.groupElement("capable"));
-    static final VarHandle const$5 = constants$5.const$4.varHandle(MemoryLayout.PathElement.groupElement("want"));
-}
-
-
diff --git a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/constants$7.java b/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/constants$7.java
deleted file mode 100644
index 493fb037..00000000
--- a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/constants$7.java
+++ /dev/null
@@ -1,30 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.win.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$7 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$7() {}
-    static final VarHandle const$0 = constants$5.const$4.varHandle(MemoryLayout.PathElement.groupElement("max_background"));
-    static final VarHandle const$1 = constants$5.const$4.varHandle(MemoryLayout.PathElement.groupElement("congestion_threshold"));
-    static final VarHandle const$2 = constants$5.const$4.varHandle(MemoryLayout.PathElement.groupElement("time_gran"));
-    static final FunctionDescriptor const$3 = FunctionDescriptor.of(JAVA_INT,
-        RuntimeHelper.POINTER,
-        RuntimeHelper.POINTER,
-        RuntimeHelper.POINTER,
-        JAVA_LONG,
-        JAVA_INT
-    );
-    static final MethodHandle const$4 = RuntimeHelper.upcallHandle(fuse3_fill_dir_t.class, "apply", constants$7.const$3);
-    static final MethodHandle const$5 = RuntimeHelper.downcallHandle(
-        constants$7.const$3
-    );
-}
-
-
diff --git a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/constants$8.java b/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/constants$8.java
deleted file mode 100644
index 6f9ac431..00000000
--- a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/constants$8.java
+++ /dev/null
@@ -1,48 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.win.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$8 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$8() {}
-    static final StructLayout const$0 = MemoryLayout.structLayout(
-        JAVA_INT.withName("set_gid"),
-        JAVA_INT.withName("gid"),
-        JAVA_INT.withName("set_uid"),
-        JAVA_INT.withName("uid"),
-        JAVA_INT.withName("set_mode"),
-        JAVA_INT.withName("umask"),
-        JAVA_DOUBLE.withName("entry_timeout"),
-        JAVA_DOUBLE.withName("negative_timeout"),
-        JAVA_DOUBLE.withName("attr_timeout"),
-        JAVA_INT.withName("intr"),
-        JAVA_INT.withName("intr_signal"),
-        JAVA_INT.withName("remember"),
-        JAVA_INT.withName("hard_remove"),
-        JAVA_INT.withName("use_ino"),
-        JAVA_INT.withName("readdir_ino"),
-        JAVA_INT.withName("direct_io"),
-        JAVA_INT.withName("kernel_cache"),
-        JAVA_INT.withName("auto_cache"),
-        JAVA_INT.withName("ac_attr_timeout_set"),
-        JAVA_DOUBLE.withName("ac_attr_timeout"),
-        JAVA_INT.withName("nullpath_ok"),
-        JAVA_INT.withName("show_help"),
-        RuntimeHelper.POINTER.withName("modules"),
-        JAVA_INT.withName("debug"),
-        MemoryLayout.paddingLayout(4)
-    ).withName("fuse3_config");
-    static final VarHandle const$1 = constants$8.const$0.varHandle(MemoryLayout.PathElement.groupElement("set_gid"));
-    static final VarHandle const$2 = constants$8.const$0.varHandle(MemoryLayout.PathElement.groupElement("gid"));
-    static final VarHandle const$3 = constants$8.const$0.varHandle(MemoryLayout.PathElement.groupElement("set_uid"));
-    static final VarHandle const$4 = constants$8.const$0.varHandle(MemoryLayout.PathElement.groupElement("uid"));
-    static final VarHandle const$5 = constants$8.const$0.varHandle(MemoryLayout.PathElement.groupElement("set_mode"));
-}
-
-
diff --git a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/constants$9.java b/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/constants$9.java
deleted file mode 100644
index d5b4d079..00000000
--- a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/constants$9.java
+++ /dev/null
@@ -1,22 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.win.extr.fuse3;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-final class constants$9 {
-
-    // Suppresses default constructor, ensuring non-instantiability.
-    private constants$9() {}
-    static final VarHandle const$0 = constants$8.const$0.varHandle(MemoryLayout.PathElement.groupElement("umask"));
-    static final VarHandle const$1 = constants$8.const$0.varHandle(MemoryLayout.PathElement.groupElement("entry_timeout"));
-    static final VarHandle const$2 = constants$8.const$0.varHandle(MemoryLayout.PathElement.groupElement("negative_timeout"));
-    static final VarHandle const$3 = constants$8.const$0.varHandle(MemoryLayout.PathElement.groupElement("attr_timeout"));
-    static final VarHandle const$4 = constants$8.const$0.varHandle(MemoryLayout.PathElement.groupElement("intr"));
-    static final VarHandle const$5 = constants$8.const$0.varHandle(MemoryLayout.PathElement.groupElement("intr_signal"));
-}
-
-
diff --git a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/fuse3_config.java b/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/fuse3_config.java
index 359d2187..2b292843 100644
--- a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/fuse3_config.java
+++ b/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/fuse3_config.java
@@ -2,13 +2,18 @@
 
 package org.cryptomator.jfuse.win.extr.fuse3;
 
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
+import java.lang.invoke.*;
 import java.lang.foreign.*;
+import java.nio.ByteOrder;
+import java.util.*;
+import java.util.function.*;
+import java.util.stream.*;
+
 import static java.lang.foreign.ValueLayout.*;
+import static java.lang.foreign.MemoryLayout.PathElement.*;
+
 /**
- * {@snippet :
+ * {@snippet lang=c :
  * struct fuse3_config {
  *     int set_gid;
  *     unsigned int gid;
@@ -32,670 +37,1150 @@
  *     double ac_attr_timeout;
  *     int nullpath_ok;
  *     int show_help;
- *     char* modules;
+ *     char *modules;
  *     int debug;
- * };
+ * }
  * }
  */
 public class fuse3_config {
 
-    public static MemoryLayout $LAYOUT() {
-        return constants$8.const$0;
+    fuse3_config() {
+        // Should not be called directly
+    }
+
+    private static final GroupLayout $LAYOUT = MemoryLayout.structLayout(
+        fuse_h.C_INT.withName("set_gid"),
+        fuse_h.C_INT.withName("gid"),
+        fuse_h.C_INT.withName("set_uid"),
+        fuse_h.C_INT.withName("uid"),
+        fuse_h.C_INT.withName("set_mode"),
+        fuse_h.C_INT.withName("umask"),
+        fuse_h.C_DOUBLE.withName("entry_timeout"),
+        fuse_h.C_DOUBLE.withName("negative_timeout"),
+        fuse_h.C_DOUBLE.withName("attr_timeout"),
+        fuse_h.C_INT.withName("intr"),
+        fuse_h.C_INT.withName("intr_signal"),
+        fuse_h.C_INT.withName("remember"),
+        fuse_h.C_INT.withName("hard_remove"),
+        fuse_h.C_INT.withName("use_ino"),
+        fuse_h.C_INT.withName("readdir_ino"),
+        fuse_h.C_INT.withName("direct_io"),
+        fuse_h.C_INT.withName("kernel_cache"),
+        fuse_h.C_INT.withName("auto_cache"),
+        fuse_h.C_INT.withName("ac_attr_timeout_set"),
+        fuse_h.C_DOUBLE.withName("ac_attr_timeout"),
+        fuse_h.C_INT.withName("nullpath_ok"),
+        fuse_h.C_INT.withName("show_help"),
+        fuse_h.C_POINTER.withName("modules"),
+        fuse_h.C_INT.withName("debug"),
+        MemoryLayout.paddingLayout(4)
+    ).withName("fuse3_config");
+
+    /**
+     * The layout of this struct
+     */
+    public static final GroupLayout layout() {
+        return $LAYOUT;
+    }
+
+    private static final OfInt set_gid$LAYOUT = (OfInt)$LAYOUT.select(groupElement("set_gid"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int set_gid
+     * }
+     */
+    public static final OfInt set_gid$layout() {
+        return set_gid$LAYOUT;
     }
-    public static VarHandle set_gid$VH() {
-        return constants$8.const$1;
+
+    private static final long set_gid$OFFSET = 0;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int set_gid
+     * }
+     */
+    public static final long set_gid$offset() {
+        return set_gid$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int set_gid;
+     * {@snippet lang=c :
+     * int set_gid
      * }
      */
-    public static int set_gid$get(MemorySegment seg) {
-        return (int)constants$8.const$1.get(seg);
+    public static int set_gid(MemorySegment struct) {
+        return struct.get(set_gid$LAYOUT, set_gid$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int set_gid;
+     * {@snippet lang=c :
+     * int set_gid
      * }
      */
-    public static void set_gid$set(MemorySegment seg, int x) {
-        constants$8.const$1.set(seg, x);
-    }
-    public static int set_gid$get(MemorySegment seg, long index) {
-        return (int)constants$8.const$1.get(seg.asSlice(index*sizeof()));
+    public static void set_gid(MemorySegment struct, int fieldValue) {
+        struct.set(set_gid$LAYOUT, set_gid$OFFSET, fieldValue);
     }
-    public static void set_gid$set(MemorySegment seg, long index, int x) {
-        constants$8.const$1.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt gid$LAYOUT = (OfInt)$LAYOUT.select(groupElement("gid"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * unsigned int gid
+     * }
+     */
+    public static final OfInt gid$layout() {
+        return gid$LAYOUT;
     }
-    public static VarHandle gid$VH() {
-        return constants$8.const$2;
+
+    private static final long gid$OFFSET = 4;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * unsigned int gid
+     * }
+     */
+    public static final long gid$offset() {
+        return gid$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned int gid;
+     * {@snippet lang=c :
+     * unsigned int gid
      * }
      */
-    public static int gid$get(MemorySegment seg) {
-        return (int)constants$8.const$2.get(seg);
+    public static int gid(MemorySegment struct) {
+        return struct.get(gid$LAYOUT, gid$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned int gid;
+     * {@snippet lang=c :
+     * unsigned int gid
      * }
      */
-    public static void gid$set(MemorySegment seg, int x) {
-        constants$8.const$2.set(seg, x);
+    public static void gid(MemorySegment struct, int fieldValue) {
+        struct.set(gid$LAYOUT, gid$OFFSET, fieldValue);
     }
-    public static int gid$get(MemorySegment seg, long index) {
-        return (int)constants$8.const$2.get(seg.asSlice(index*sizeof()));
-    }
-    public static void gid$set(MemorySegment seg, long index, int x) {
-        constants$8.const$2.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt set_uid$LAYOUT = (OfInt)$LAYOUT.select(groupElement("set_uid"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int set_uid
+     * }
+     */
+    public static final OfInt set_uid$layout() {
+        return set_uid$LAYOUT;
     }
-    public static VarHandle set_uid$VH() {
-        return constants$8.const$3;
+
+    private static final long set_uid$OFFSET = 8;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int set_uid
+     * }
+     */
+    public static final long set_uid$offset() {
+        return set_uid$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int set_uid;
+     * {@snippet lang=c :
+     * int set_uid
      * }
      */
-    public static int set_uid$get(MemorySegment seg) {
-        return (int)constants$8.const$3.get(seg);
+    public static int set_uid(MemorySegment struct) {
+        return struct.get(set_uid$LAYOUT, set_uid$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int set_uid;
+     * {@snippet lang=c :
+     * int set_uid
      * }
      */
-    public static void set_uid$set(MemorySegment seg, int x) {
-        constants$8.const$3.set(seg, x);
+    public static void set_uid(MemorySegment struct, int fieldValue) {
+        struct.set(set_uid$LAYOUT, set_uid$OFFSET, fieldValue);
     }
-    public static int set_uid$get(MemorySegment seg, long index) {
-        return (int)constants$8.const$3.get(seg.asSlice(index*sizeof()));
-    }
-    public static void set_uid$set(MemorySegment seg, long index, int x) {
-        constants$8.const$3.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt uid$LAYOUT = (OfInt)$LAYOUT.select(groupElement("uid"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * unsigned int uid
+     * }
+     */
+    public static final OfInt uid$layout() {
+        return uid$LAYOUT;
     }
-    public static VarHandle uid$VH() {
-        return constants$8.const$4;
+
+    private static final long uid$OFFSET = 12;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * unsigned int uid
+     * }
+     */
+    public static final long uid$offset() {
+        return uid$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned int uid;
+     * {@snippet lang=c :
+     * unsigned int uid
      * }
      */
-    public static int uid$get(MemorySegment seg) {
-        return (int)constants$8.const$4.get(seg);
+    public static int uid(MemorySegment struct) {
+        return struct.get(uid$LAYOUT, uid$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned int uid;
+     * {@snippet lang=c :
+     * unsigned int uid
      * }
      */
-    public static void uid$set(MemorySegment seg, int x) {
-        constants$8.const$4.set(seg, x);
-    }
-    public static int uid$get(MemorySegment seg, long index) {
-        return (int)constants$8.const$4.get(seg.asSlice(index*sizeof()));
+    public static void uid(MemorySegment struct, int fieldValue) {
+        struct.set(uid$LAYOUT, uid$OFFSET, fieldValue);
     }
-    public static void uid$set(MemorySegment seg, long index, int x) {
-        constants$8.const$4.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt set_mode$LAYOUT = (OfInt)$LAYOUT.select(groupElement("set_mode"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int set_mode
+     * }
+     */
+    public static final OfInt set_mode$layout() {
+        return set_mode$LAYOUT;
     }
-    public static VarHandle set_mode$VH() {
-        return constants$8.const$5;
+
+    private static final long set_mode$OFFSET = 16;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int set_mode
+     * }
+     */
+    public static final long set_mode$offset() {
+        return set_mode$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int set_mode;
+     * {@snippet lang=c :
+     * int set_mode
      * }
      */
-    public static int set_mode$get(MemorySegment seg) {
-        return (int)constants$8.const$5.get(seg);
+    public static int set_mode(MemorySegment struct) {
+        return struct.get(set_mode$LAYOUT, set_mode$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int set_mode;
+     * {@snippet lang=c :
+     * int set_mode
      * }
      */
-    public static void set_mode$set(MemorySegment seg, int x) {
-        constants$8.const$5.set(seg, x);
-    }
-    public static int set_mode$get(MemorySegment seg, long index) {
-        return (int)constants$8.const$5.get(seg.asSlice(index*sizeof()));
+    public static void set_mode(MemorySegment struct, int fieldValue) {
+        struct.set(set_mode$LAYOUT, set_mode$OFFSET, fieldValue);
     }
-    public static void set_mode$set(MemorySegment seg, long index, int x) {
-        constants$8.const$5.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt umask$LAYOUT = (OfInt)$LAYOUT.select(groupElement("umask"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * unsigned int umask
+     * }
+     */
+    public static final OfInt umask$layout() {
+        return umask$LAYOUT;
     }
-    public static VarHandle umask$VH() {
-        return constants$9.const$0;
+
+    private static final long umask$OFFSET = 20;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * unsigned int umask
+     * }
+     */
+    public static final long umask$offset() {
+        return umask$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned int umask;
+     * {@snippet lang=c :
+     * unsigned int umask
      * }
      */
-    public static int umask$get(MemorySegment seg) {
-        return (int)constants$9.const$0.get(seg);
+    public static int umask(MemorySegment struct) {
+        return struct.get(umask$LAYOUT, umask$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned int umask;
+     * {@snippet lang=c :
+     * unsigned int umask
      * }
      */
-    public static void umask$set(MemorySegment seg, int x) {
-        constants$9.const$0.set(seg, x);
-    }
-    public static int umask$get(MemorySegment seg, long index) {
-        return (int)constants$9.const$0.get(seg.asSlice(index*sizeof()));
+    public static void umask(MemorySegment struct, int fieldValue) {
+        struct.set(umask$LAYOUT, umask$OFFSET, fieldValue);
     }
-    public static void umask$set(MemorySegment seg, long index, int x) {
-        constants$9.const$0.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfDouble entry_timeout$LAYOUT = (OfDouble)$LAYOUT.select(groupElement("entry_timeout"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * double entry_timeout
+     * }
+     */
+    public static final OfDouble entry_timeout$layout() {
+        return entry_timeout$LAYOUT;
     }
-    public static VarHandle entry_timeout$VH() {
-        return constants$9.const$1;
+
+    private static final long entry_timeout$OFFSET = 24;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * double entry_timeout
+     * }
+     */
+    public static final long entry_timeout$offset() {
+        return entry_timeout$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * double entry_timeout;
+     * {@snippet lang=c :
+     * double entry_timeout
      * }
      */
-    public static double entry_timeout$get(MemorySegment seg) {
-        return (double)constants$9.const$1.get(seg);
+    public static double entry_timeout(MemorySegment struct) {
+        return struct.get(entry_timeout$LAYOUT, entry_timeout$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * double entry_timeout;
+     * {@snippet lang=c :
+     * double entry_timeout
      * }
      */
-    public static void entry_timeout$set(MemorySegment seg, double x) {
-        constants$9.const$1.set(seg, x);
-    }
-    public static double entry_timeout$get(MemorySegment seg, long index) {
-        return (double)constants$9.const$1.get(seg.asSlice(index*sizeof()));
+    public static void entry_timeout(MemorySegment struct, double fieldValue) {
+        struct.set(entry_timeout$LAYOUT, entry_timeout$OFFSET, fieldValue);
     }
-    public static void entry_timeout$set(MemorySegment seg, long index, double x) {
-        constants$9.const$1.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfDouble negative_timeout$LAYOUT = (OfDouble)$LAYOUT.select(groupElement("negative_timeout"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * double negative_timeout
+     * }
+     */
+    public static final OfDouble negative_timeout$layout() {
+        return negative_timeout$LAYOUT;
     }
-    public static VarHandle negative_timeout$VH() {
-        return constants$9.const$2;
+
+    private static final long negative_timeout$OFFSET = 32;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * double negative_timeout
+     * }
+     */
+    public static final long negative_timeout$offset() {
+        return negative_timeout$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * double negative_timeout;
+     * {@snippet lang=c :
+     * double negative_timeout
      * }
      */
-    public static double negative_timeout$get(MemorySegment seg) {
-        return (double)constants$9.const$2.get(seg);
+    public static double negative_timeout(MemorySegment struct) {
+        return struct.get(negative_timeout$LAYOUT, negative_timeout$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * double negative_timeout;
+     * {@snippet lang=c :
+     * double negative_timeout
      * }
      */
-    public static void negative_timeout$set(MemorySegment seg, double x) {
-        constants$9.const$2.set(seg, x);
+    public static void negative_timeout(MemorySegment struct, double fieldValue) {
+        struct.set(negative_timeout$LAYOUT, negative_timeout$OFFSET, fieldValue);
     }
-    public static double negative_timeout$get(MemorySegment seg, long index) {
-        return (double)constants$9.const$2.get(seg.asSlice(index*sizeof()));
-    }
-    public static void negative_timeout$set(MemorySegment seg, long index, double x) {
-        constants$9.const$2.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfDouble attr_timeout$LAYOUT = (OfDouble)$LAYOUT.select(groupElement("attr_timeout"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * double attr_timeout
+     * }
+     */
+    public static final OfDouble attr_timeout$layout() {
+        return attr_timeout$LAYOUT;
     }
-    public static VarHandle attr_timeout$VH() {
-        return constants$9.const$3;
+
+    private static final long attr_timeout$OFFSET = 40;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * double attr_timeout
+     * }
+     */
+    public static final long attr_timeout$offset() {
+        return attr_timeout$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * double attr_timeout;
+     * {@snippet lang=c :
+     * double attr_timeout
      * }
      */
-    public static double attr_timeout$get(MemorySegment seg) {
-        return (double)constants$9.const$3.get(seg);
+    public static double attr_timeout(MemorySegment struct) {
+        return struct.get(attr_timeout$LAYOUT, attr_timeout$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * double attr_timeout;
+     * {@snippet lang=c :
+     * double attr_timeout
      * }
      */
-    public static void attr_timeout$set(MemorySegment seg, double x) {
-        constants$9.const$3.set(seg, x);
+    public static void attr_timeout(MemorySegment struct, double fieldValue) {
+        struct.set(attr_timeout$LAYOUT, attr_timeout$OFFSET, fieldValue);
     }
-    public static double attr_timeout$get(MemorySegment seg, long index) {
-        return (double)constants$9.const$3.get(seg.asSlice(index*sizeof()));
-    }
-    public static void attr_timeout$set(MemorySegment seg, long index, double x) {
-        constants$9.const$3.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt intr$LAYOUT = (OfInt)$LAYOUT.select(groupElement("intr"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int intr
+     * }
+     */
+    public static final OfInt intr$layout() {
+        return intr$LAYOUT;
     }
-    public static VarHandle intr$VH() {
-        return constants$9.const$4;
+
+    private static final long intr$OFFSET = 48;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int intr
+     * }
+     */
+    public static final long intr$offset() {
+        return intr$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int intr;
+     * {@snippet lang=c :
+     * int intr
      * }
      */
-    public static int intr$get(MemorySegment seg) {
-        return (int)constants$9.const$4.get(seg);
+    public static int intr(MemorySegment struct) {
+        return struct.get(intr$LAYOUT, intr$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int intr;
+     * {@snippet lang=c :
+     * int intr
      * }
      */
-    public static void intr$set(MemorySegment seg, int x) {
-        constants$9.const$4.set(seg, x);
+    public static void intr(MemorySegment struct, int fieldValue) {
+        struct.set(intr$LAYOUT, intr$OFFSET, fieldValue);
     }
-    public static int intr$get(MemorySegment seg, long index) {
-        return (int)constants$9.const$4.get(seg.asSlice(index*sizeof()));
-    }
-    public static void intr$set(MemorySegment seg, long index, int x) {
-        constants$9.const$4.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt intr_signal$LAYOUT = (OfInt)$LAYOUT.select(groupElement("intr_signal"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int intr_signal
+     * }
+     */
+    public static final OfInt intr_signal$layout() {
+        return intr_signal$LAYOUT;
     }
-    public static VarHandle intr_signal$VH() {
-        return constants$9.const$5;
+
+    private static final long intr_signal$OFFSET = 52;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int intr_signal
+     * }
+     */
+    public static final long intr_signal$offset() {
+        return intr_signal$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int intr_signal;
+     * {@snippet lang=c :
+     * int intr_signal
      * }
      */
-    public static int intr_signal$get(MemorySegment seg) {
-        return (int)constants$9.const$5.get(seg);
+    public static int intr_signal(MemorySegment struct) {
+        return struct.get(intr_signal$LAYOUT, intr_signal$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int intr_signal;
+     * {@snippet lang=c :
+     * int intr_signal
      * }
      */
-    public static void intr_signal$set(MemorySegment seg, int x) {
-        constants$9.const$5.set(seg, x);
-    }
-    public static int intr_signal$get(MemorySegment seg, long index) {
-        return (int)constants$9.const$5.get(seg.asSlice(index*sizeof()));
+    public static void intr_signal(MemorySegment struct, int fieldValue) {
+        struct.set(intr_signal$LAYOUT, intr_signal$OFFSET, fieldValue);
     }
-    public static void intr_signal$set(MemorySegment seg, long index, int x) {
-        constants$9.const$5.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt remember$LAYOUT = (OfInt)$LAYOUT.select(groupElement("remember"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int remember
+     * }
+     */
+    public static final OfInt remember$layout() {
+        return remember$LAYOUT;
     }
-    public static VarHandle remember$VH() {
-        return constants$10.const$0;
+
+    private static final long remember$OFFSET = 56;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int remember
+     * }
+     */
+    public static final long remember$offset() {
+        return remember$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int remember;
+     * {@snippet lang=c :
+     * int remember
      * }
      */
-    public static int remember$get(MemorySegment seg) {
-        return (int)constants$10.const$0.get(seg);
+    public static int remember(MemorySegment struct) {
+        return struct.get(remember$LAYOUT, remember$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int remember;
+     * {@snippet lang=c :
+     * int remember
      * }
      */
-    public static void remember$set(MemorySegment seg, int x) {
-        constants$10.const$0.set(seg, x);
-    }
-    public static int remember$get(MemorySegment seg, long index) {
-        return (int)constants$10.const$0.get(seg.asSlice(index*sizeof()));
+    public static void remember(MemorySegment struct, int fieldValue) {
+        struct.set(remember$LAYOUT, remember$OFFSET, fieldValue);
     }
-    public static void remember$set(MemorySegment seg, long index, int x) {
-        constants$10.const$0.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt hard_remove$LAYOUT = (OfInt)$LAYOUT.select(groupElement("hard_remove"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int hard_remove
+     * }
+     */
+    public static final OfInt hard_remove$layout() {
+        return hard_remove$LAYOUT;
     }
-    public static VarHandle hard_remove$VH() {
-        return constants$10.const$1;
+
+    private static final long hard_remove$OFFSET = 60;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int hard_remove
+     * }
+     */
+    public static final long hard_remove$offset() {
+        return hard_remove$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int hard_remove;
+     * {@snippet lang=c :
+     * int hard_remove
      * }
      */
-    public static int hard_remove$get(MemorySegment seg) {
-        return (int)constants$10.const$1.get(seg);
+    public static int hard_remove(MemorySegment struct) {
+        return struct.get(hard_remove$LAYOUT, hard_remove$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int hard_remove;
+     * {@snippet lang=c :
+     * int hard_remove
      * }
      */
-    public static void hard_remove$set(MemorySegment seg, int x) {
-        constants$10.const$1.set(seg, x);
-    }
-    public static int hard_remove$get(MemorySegment seg, long index) {
-        return (int)constants$10.const$1.get(seg.asSlice(index*sizeof()));
+    public static void hard_remove(MemorySegment struct, int fieldValue) {
+        struct.set(hard_remove$LAYOUT, hard_remove$OFFSET, fieldValue);
     }
-    public static void hard_remove$set(MemorySegment seg, long index, int x) {
-        constants$10.const$1.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt use_ino$LAYOUT = (OfInt)$LAYOUT.select(groupElement("use_ino"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int use_ino
+     * }
+     */
+    public static final OfInt use_ino$layout() {
+        return use_ino$LAYOUT;
     }
-    public static VarHandle use_ino$VH() {
-        return constants$10.const$2;
+
+    private static final long use_ino$OFFSET = 64;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int use_ino
+     * }
+     */
+    public static final long use_ino$offset() {
+        return use_ino$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int use_ino;
+     * {@snippet lang=c :
+     * int use_ino
      * }
      */
-    public static int use_ino$get(MemorySegment seg) {
-        return (int)constants$10.const$2.get(seg);
+    public static int use_ino(MemorySegment struct) {
+        return struct.get(use_ino$LAYOUT, use_ino$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int use_ino;
+     * {@snippet lang=c :
+     * int use_ino
      * }
      */
-    public static void use_ino$set(MemorySegment seg, int x) {
-        constants$10.const$2.set(seg, x);
+    public static void use_ino(MemorySegment struct, int fieldValue) {
+        struct.set(use_ino$LAYOUT, use_ino$OFFSET, fieldValue);
     }
-    public static int use_ino$get(MemorySegment seg, long index) {
-        return (int)constants$10.const$2.get(seg.asSlice(index*sizeof()));
-    }
-    public static void use_ino$set(MemorySegment seg, long index, int x) {
-        constants$10.const$2.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt readdir_ino$LAYOUT = (OfInt)$LAYOUT.select(groupElement("readdir_ino"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int readdir_ino
+     * }
+     */
+    public static final OfInt readdir_ino$layout() {
+        return readdir_ino$LAYOUT;
     }
-    public static VarHandle readdir_ino$VH() {
-        return constants$10.const$3;
+
+    private static final long readdir_ino$OFFSET = 68;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int readdir_ino
+     * }
+     */
+    public static final long readdir_ino$offset() {
+        return readdir_ino$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int readdir_ino;
+     * {@snippet lang=c :
+     * int readdir_ino
      * }
      */
-    public static int readdir_ino$get(MemorySegment seg) {
-        return (int)constants$10.const$3.get(seg);
+    public static int readdir_ino(MemorySegment struct) {
+        return struct.get(readdir_ino$LAYOUT, readdir_ino$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int readdir_ino;
+     * {@snippet lang=c :
+     * int readdir_ino
      * }
      */
-    public static void readdir_ino$set(MemorySegment seg, int x) {
-        constants$10.const$3.set(seg, x);
+    public static void readdir_ino(MemorySegment struct, int fieldValue) {
+        struct.set(readdir_ino$LAYOUT, readdir_ino$OFFSET, fieldValue);
     }
-    public static int readdir_ino$get(MemorySegment seg, long index) {
-        return (int)constants$10.const$3.get(seg.asSlice(index*sizeof()));
-    }
-    public static void readdir_ino$set(MemorySegment seg, long index, int x) {
-        constants$10.const$3.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt direct_io$LAYOUT = (OfInt)$LAYOUT.select(groupElement("direct_io"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int direct_io
+     * }
+     */
+    public static final OfInt direct_io$layout() {
+        return direct_io$LAYOUT;
     }
-    public static VarHandle direct_io$VH() {
-        return constants$10.const$4;
+
+    private static final long direct_io$OFFSET = 72;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int direct_io
+     * }
+     */
+    public static final long direct_io$offset() {
+        return direct_io$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int direct_io;
+     * {@snippet lang=c :
+     * int direct_io
      * }
      */
-    public static int direct_io$get(MemorySegment seg) {
-        return (int)constants$10.const$4.get(seg);
+    public static int direct_io(MemorySegment struct) {
+        return struct.get(direct_io$LAYOUT, direct_io$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int direct_io;
+     * {@snippet lang=c :
+     * int direct_io
      * }
      */
-    public static void direct_io$set(MemorySegment seg, int x) {
-        constants$10.const$4.set(seg, x);
+    public static void direct_io(MemorySegment struct, int fieldValue) {
+        struct.set(direct_io$LAYOUT, direct_io$OFFSET, fieldValue);
     }
-    public static int direct_io$get(MemorySegment seg, long index) {
-        return (int)constants$10.const$4.get(seg.asSlice(index*sizeof()));
-    }
-    public static void direct_io$set(MemorySegment seg, long index, int x) {
-        constants$10.const$4.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt kernel_cache$LAYOUT = (OfInt)$LAYOUT.select(groupElement("kernel_cache"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int kernel_cache
+     * }
+     */
+    public static final OfInt kernel_cache$layout() {
+        return kernel_cache$LAYOUT;
     }
-    public static VarHandle kernel_cache$VH() {
-        return constants$10.const$5;
+
+    private static final long kernel_cache$OFFSET = 76;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int kernel_cache
+     * }
+     */
+    public static final long kernel_cache$offset() {
+        return kernel_cache$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int kernel_cache;
+     * {@snippet lang=c :
+     * int kernel_cache
      * }
      */
-    public static int kernel_cache$get(MemorySegment seg) {
-        return (int)constants$10.const$5.get(seg);
+    public static int kernel_cache(MemorySegment struct) {
+        return struct.get(kernel_cache$LAYOUT, kernel_cache$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int kernel_cache;
+     * {@snippet lang=c :
+     * int kernel_cache
      * }
      */
-    public static void kernel_cache$set(MemorySegment seg, int x) {
-        constants$10.const$5.set(seg, x);
-    }
-    public static int kernel_cache$get(MemorySegment seg, long index) {
-        return (int)constants$10.const$5.get(seg.asSlice(index*sizeof()));
+    public static void kernel_cache(MemorySegment struct, int fieldValue) {
+        struct.set(kernel_cache$LAYOUT, kernel_cache$OFFSET, fieldValue);
     }
-    public static void kernel_cache$set(MemorySegment seg, long index, int x) {
-        constants$10.const$5.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt auto_cache$LAYOUT = (OfInt)$LAYOUT.select(groupElement("auto_cache"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int auto_cache
+     * }
+     */
+    public static final OfInt auto_cache$layout() {
+        return auto_cache$LAYOUT;
     }
-    public static VarHandle auto_cache$VH() {
-        return constants$11.const$0;
+
+    private static final long auto_cache$OFFSET = 80;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int auto_cache
+     * }
+     */
+    public static final long auto_cache$offset() {
+        return auto_cache$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int auto_cache;
+     * {@snippet lang=c :
+     * int auto_cache
      * }
      */
-    public static int auto_cache$get(MemorySegment seg) {
-        return (int)constants$11.const$0.get(seg);
+    public static int auto_cache(MemorySegment struct) {
+        return struct.get(auto_cache$LAYOUT, auto_cache$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int auto_cache;
+     * {@snippet lang=c :
+     * int auto_cache
      * }
      */
-    public static void auto_cache$set(MemorySegment seg, int x) {
-        constants$11.const$0.set(seg, x);
-    }
-    public static int auto_cache$get(MemorySegment seg, long index) {
-        return (int)constants$11.const$0.get(seg.asSlice(index*sizeof()));
+    public static void auto_cache(MemorySegment struct, int fieldValue) {
+        struct.set(auto_cache$LAYOUT, auto_cache$OFFSET, fieldValue);
     }
-    public static void auto_cache$set(MemorySegment seg, long index, int x) {
-        constants$11.const$0.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt ac_attr_timeout_set$LAYOUT = (OfInt)$LAYOUT.select(groupElement("ac_attr_timeout_set"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int ac_attr_timeout_set
+     * }
+     */
+    public static final OfInt ac_attr_timeout_set$layout() {
+        return ac_attr_timeout_set$LAYOUT;
     }
-    public static VarHandle ac_attr_timeout_set$VH() {
-        return constants$11.const$1;
+
+    private static final long ac_attr_timeout_set$OFFSET = 84;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int ac_attr_timeout_set
+     * }
+     */
+    public static final long ac_attr_timeout_set$offset() {
+        return ac_attr_timeout_set$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int ac_attr_timeout_set;
+     * {@snippet lang=c :
+     * int ac_attr_timeout_set
      * }
      */
-    public static int ac_attr_timeout_set$get(MemorySegment seg) {
-        return (int)constants$11.const$1.get(seg);
+    public static int ac_attr_timeout_set(MemorySegment struct) {
+        return struct.get(ac_attr_timeout_set$LAYOUT, ac_attr_timeout_set$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int ac_attr_timeout_set;
+     * {@snippet lang=c :
+     * int ac_attr_timeout_set
      * }
      */
-    public static void ac_attr_timeout_set$set(MemorySegment seg, int x) {
-        constants$11.const$1.set(seg, x);
-    }
-    public static int ac_attr_timeout_set$get(MemorySegment seg, long index) {
-        return (int)constants$11.const$1.get(seg.asSlice(index*sizeof()));
+    public static void ac_attr_timeout_set(MemorySegment struct, int fieldValue) {
+        struct.set(ac_attr_timeout_set$LAYOUT, ac_attr_timeout_set$OFFSET, fieldValue);
     }
-    public static void ac_attr_timeout_set$set(MemorySegment seg, long index, int x) {
-        constants$11.const$1.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfDouble ac_attr_timeout$LAYOUT = (OfDouble)$LAYOUT.select(groupElement("ac_attr_timeout"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * double ac_attr_timeout
+     * }
+     */
+    public static final OfDouble ac_attr_timeout$layout() {
+        return ac_attr_timeout$LAYOUT;
     }
-    public static VarHandle ac_attr_timeout$VH() {
-        return constants$11.const$2;
+
+    private static final long ac_attr_timeout$OFFSET = 88;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * double ac_attr_timeout
+     * }
+     */
+    public static final long ac_attr_timeout$offset() {
+        return ac_attr_timeout$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * double ac_attr_timeout;
+     * {@snippet lang=c :
+     * double ac_attr_timeout
      * }
      */
-    public static double ac_attr_timeout$get(MemorySegment seg) {
-        return (double)constants$11.const$2.get(seg);
+    public static double ac_attr_timeout(MemorySegment struct) {
+        return struct.get(ac_attr_timeout$LAYOUT, ac_attr_timeout$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * double ac_attr_timeout;
+     * {@snippet lang=c :
+     * double ac_attr_timeout
      * }
      */
-    public static void ac_attr_timeout$set(MemorySegment seg, double x) {
-        constants$11.const$2.set(seg, x);
-    }
-    public static double ac_attr_timeout$get(MemorySegment seg, long index) {
-        return (double)constants$11.const$2.get(seg.asSlice(index*sizeof()));
+    public static void ac_attr_timeout(MemorySegment struct, double fieldValue) {
+        struct.set(ac_attr_timeout$LAYOUT, ac_attr_timeout$OFFSET, fieldValue);
     }
-    public static void ac_attr_timeout$set(MemorySegment seg, long index, double x) {
-        constants$11.const$2.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt nullpath_ok$LAYOUT = (OfInt)$LAYOUT.select(groupElement("nullpath_ok"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int nullpath_ok
+     * }
+     */
+    public static final OfInt nullpath_ok$layout() {
+        return nullpath_ok$LAYOUT;
     }
-    public static VarHandle nullpath_ok$VH() {
-        return constants$11.const$3;
+
+    private static final long nullpath_ok$OFFSET = 96;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int nullpath_ok
+     * }
+     */
+    public static final long nullpath_ok$offset() {
+        return nullpath_ok$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int nullpath_ok;
+     * {@snippet lang=c :
+     * int nullpath_ok
      * }
      */
-    public static int nullpath_ok$get(MemorySegment seg) {
-        return (int)constants$11.const$3.get(seg);
+    public static int nullpath_ok(MemorySegment struct) {
+        return struct.get(nullpath_ok$LAYOUT, nullpath_ok$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int nullpath_ok;
+     * {@snippet lang=c :
+     * int nullpath_ok
      * }
      */
-    public static void nullpath_ok$set(MemorySegment seg, int x) {
-        constants$11.const$3.set(seg, x);
+    public static void nullpath_ok(MemorySegment struct, int fieldValue) {
+        struct.set(nullpath_ok$LAYOUT, nullpath_ok$OFFSET, fieldValue);
     }
-    public static int nullpath_ok$get(MemorySegment seg, long index) {
-        return (int)constants$11.const$3.get(seg.asSlice(index*sizeof()));
-    }
-    public static void nullpath_ok$set(MemorySegment seg, long index, int x) {
-        constants$11.const$3.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt show_help$LAYOUT = (OfInt)$LAYOUT.select(groupElement("show_help"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int show_help
+     * }
+     */
+    public static final OfInt show_help$layout() {
+        return show_help$LAYOUT;
     }
-    public static VarHandle show_help$VH() {
-        return constants$11.const$4;
+
+    private static final long show_help$OFFSET = 100;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int show_help
+     * }
+     */
+    public static final long show_help$offset() {
+        return show_help$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int show_help;
+     * {@snippet lang=c :
+     * int show_help
      * }
      */
-    public static int show_help$get(MemorySegment seg) {
-        return (int)constants$11.const$4.get(seg);
+    public static int show_help(MemorySegment struct) {
+        return struct.get(show_help$LAYOUT, show_help$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int show_help;
+     * {@snippet lang=c :
+     * int show_help
      * }
      */
-    public static void show_help$set(MemorySegment seg, int x) {
-        constants$11.const$4.set(seg, x);
+    public static void show_help(MemorySegment struct, int fieldValue) {
+        struct.set(show_help$LAYOUT, show_help$OFFSET, fieldValue);
     }
-    public static int show_help$get(MemorySegment seg, long index) {
-        return (int)constants$11.const$4.get(seg.asSlice(index*sizeof()));
-    }
-    public static void show_help$set(MemorySegment seg, long index, int x) {
-        constants$11.const$4.set(seg.asSlice(index*sizeof()), x);
+
+    private static final AddressLayout modules$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("modules"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * char *modules
+     * }
+     */
+    public static final AddressLayout modules$layout() {
+        return modules$LAYOUT;
     }
-    public static VarHandle modules$VH() {
-        return constants$11.const$5;
+
+    private static final long modules$OFFSET = 104;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * char *modules
+     * }
+     */
+    public static final long modules$offset() {
+        return modules$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * char* modules;
+     * {@snippet lang=c :
+     * char *modules
      * }
      */
-    public static MemorySegment modules$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$11.const$5.get(seg);
+    public static MemorySegment modules(MemorySegment struct) {
+        return struct.get(modules$LAYOUT, modules$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * char* modules;
+     * {@snippet lang=c :
+     * char *modules
      * }
      */
-    public static void modules$set(MemorySegment seg, MemorySegment x) {
-        constants$11.const$5.set(seg, x);
-    }
-    public static MemorySegment modules$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$11.const$5.get(seg.asSlice(index*sizeof()));
+    public static void modules(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(modules$LAYOUT, modules$OFFSET, fieldValue);
     }
-    public static void modules$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$11.const$5.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt debug$LAYOUT = (OfInt)$LAYOUT.select(groupElement("debug"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int debug
+     * }
+     */
+    public static final OfInt debug$layout() {
+        return debug$LAYOUT;
     }
-    public static VarHandle debug$VH() {
-        return constants$12.const$0;
+
+    private static final long debug$OFFSET = 112;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int debug
+     * }
+     */
+    public static final long debug$offset() {
+        return debug$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int debug;
+     * {@snippet lang=c :
+     * int debug
      * }
      */
-    public static int debug$get(MemorySegment seg) {
-        return (int)constants$12.const$0.get(seg);
+    public static int debug(MemorySegment struct) {
+        return struct.get(debug$LAYOUT, debug$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int debug;
+     * {@snippet lang=c :
+     * int debug
      * }
      */
-    public static void debug$set(MemorySegment seg, int x) {
-        constants$12.const$0.set(seg, x);
+    public static void debug(MemorySegment struct, int fieldValue) {
+        struct.set(debug$LAYOUT, debug$OFFSET, fieldValue);
     }
-    public static int debug$get(MemorySegment seg, long index) {
-        return (int)constants$12.const$0.get(seg.asSlice(index*sizeof()));
+
+    /**
+     * Obtains a slice of {@code arrayParam} which selects the array element at {@code index}.
+     * The returned segment has address {@code arrayParam.address() + index * layout().byteSize()}
+     */
+    public static MemorySegment asSlice(MemorySegment array, long index) {
+        return array.asSlice(layout().byteSize() * index);
     }
-    public static void debug$set(MemorySegment seg, long index, int x) {
-        constants$12.const$0.set(seg.asSlice(index*sizeof()), x);
+
+    /**
+     * The size (in bytes) of this struct
+     */
+    public static long sizeof() { return layout().byteSize(); }
+
+    /**
+     * Allocate a segment of size {@code layout().byteSize()} using {@code allocator}
+     */
+    public static MemorySegment allocate(SegmentAllocator allocator) {
+        return allocator.allocate(layout());
     }
-    public static long sizeof() { return $LAYOUT().byteSize(); }
-    public static MemorySegment allocate(SegmentAllocator allocator) { return allocator.allocate($LAYOUT()); }
-    public static MemorySegment allocateArray(long len, SegmentAllocator allocator) {
-        return allocator.allocate(MemoryLayout.sequenceLayout(len, $LAYOUT()));
+
+    /**
+     * Allocate an array of size {@code elementCount} using {@code allocator}.
+     * The returned segment has size {@code elementCount * layout().byteSize()}.
+     */
+    public static MemorySegment allocateArray(long elementCount, SegmentAllocator allocator) {
+        return allocator.allocate(MemoryLayout.sequenceLayout(elementCount, layout()));
+    }
+
+    /**
+     * Reinterprets {@code addr} using target {@code arena} and {@code cleanupAction) (if any).
+     * The returned segment has size {@code layout().byteSize()}
+     */
+    public static MemorySegment reinterpret(MemorySegment addr, Arena arena, Consumer<MemorySegment> cleanup) {
+        return reinterpret(addr, 1, arena, cleanup);
     }
-    public static MemorySegment ofAddress(MemorySegment addr, Arena scope) { return RuntimeHelper.asArray(addr, $LAYOUT(), 1, scope); }
-}
 
+    /**
+     * Reinterprets {@code addr} using target {@code arena} and {@code cleanupAction) (if any).
+     * The returned segment has size {@code elementCount * layout().byteSize()}
+     */
+    public static MemorySegment reinterpret(MemorySegment addr, long elementCount, Arena arena, Consumer<MemorySegment> cleanup) {
+        return addr.reinterpret(layout().byteSize() * elementCount, arena, cleanup);
+    }
+}
 
diff --git a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/fuse3_conn_info.java b/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/fuse3_conn_info.java
index 686f3ab9..6ad28959 100644
--- a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/fuse3_conn_info.java
+++ b/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/fuse3_conn_info.java
@@ -2,13 +2,18 @@
 
 package org.cryptomator.jfuse.win.extr.fuse3;
 
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
+import java.lang.invoke.*;
 import java.lang.foreign.*;
+import java.nio.ByteOrder;
+import java.util.*;
+import java.util.function.*;
+import java.util.stream.*;
+
 import static java.lang.foreign.ValueLayout.*;
+import static java.lang.foreign.MemoryLayout.PathElement.*;
+
 /**
- * {@snippet :
+ * {@snippet lang=c :
  * struct fuse3_conn_info {
  *     unsigned int proto_major;
  *     unsigned int proto_minor;
@@ -21,293 +26,595 @@
  *     unsigned int congestion_threshold;
  *     unsigned int time_gran;
  *     unsigned int reserved[22];
- * };
+ * }
  * }
  */
 public class fuse3_conn_info {
 
-    public static MemoryLayout $LAYOUT() {
-        return constants$5.const$4;
+    fuse3_conn_info() {
+        // Should not be called directly
     }
-    public static VarHandle proto_major$VH() {
-        return constants$5.const$5;
+
+    private static final GroupLayout $LAYOUT = MemoryLayout.structLayout(
+        fuse_h.C_INT.withName("proto_major"),
+        fuse_h.C_INT.withName("proto_minor"),
+        fuse_h.C_INT.withName("max_write"),
+        fuse_h.C_INT.withName("max_read"),
+        fuse_h.C_INT.withName("max_readahead"),
+        fuse_h.C_INT.withName("capable"),
+        fuse_h.C_INT.withName("want"),
+        fuse_h.C_INT.withName("max_background"),
+        fuse_h.C_INT.withName("congestion_threshold"),
+        fuse_h.C_INT.withName("time_gran"),
+        MemoryLayout.sequenceLayout(22, fuse_h.C_INT).withName("reserved")
+    ).withName("fuse3_conn_info");
+
+    /**
+     * The layout of this struct
+     */
+    public static final GroupLayout layout() {
+        return $LAYOUT;
     }
+
+    private static final OfInt proto_major$LAYOUT = (OfInt)$LAYOUT.select(groupElement("proto_major"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * unsigned int proto_major
+     * }
+     */
+    public static final OfInt proto_major$layout() {
+        return proto_major$LAYOUT;
+    }
+
+    private static final long proto_major$OFFSET = 0;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * unsigned int proto_major
+     * }
+     */
+    public static final long proto_major$offset() {
+        return proto_major$OFFSET;
+    }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned int proto_major;
+     * {@snippet lang=c :
+     * unsigned int proto_major
      * }
      */
-    public static int proto_major$get(MemorySegment seg) {
-        return (int)constants$5.const$5.get(seg);
+    public static int proto_major(MemorySegment struct) {
+        return struct.get(proto_major$LAYOUT, proto_major$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned int proto_major;
+     * {@snippet lang=c :
+     * unsigned int proto_major
      * }
      */
-    public static void proto_major$set(MemorySegment seg, int x) {
-        constants$5.const$5.set(seg, x);
-    }
-    public static int proto_major$get(MemorySegment seg, long index) {
-        return (int)constants$5.const$5.get(seg.asSlice(index*sizeof()));
+    public static void proto_major(MemorySegment struct, int fieldValue) {
+        struct.set(proto_major$LAYOUT, proto_major$OFFSET, fieldValue);
     }
-    public static void proto_major$set(MemorySegment seg, long index, int x) {
-        constants$5.const$5.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt proto_minor$LAYOUT = (OfInt)$LAYOUT.select(groupElement("proto_minor"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * unsigned int proto_minor
+     * }
+     */
+    public static final OfInt proto_minor$layout() {
+        return proto_minor$LAYOUT;
     }
-    public static VarHandle proto_minor$VH() {
-        return constants$6.const$0;
+
+    private static final long proto_minor$OFFSET = 4;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * unsigned int proto_minor
+     * }
+     */
+    public static final long proto_minor$offset() {
+        return proto_minor$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned int proto_minor;
+     * {@snippet lang=c :
+     * unsigned int proto_minor
      * }
      */
-    public static int proto_minor$get(MemorySegment seg) {
-        return (int)constants$6.const$0.get(seg);
+    public static int proto_minor(MemorySegment struct) {
+        return struct.get(proto_minor$LAYOUT, proto_minor$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned int proto_minor;
+     * {@snippet lang=c :
+     * unsigned int proto_minor
      * }
      */
-    public static void proto_minor$set(MemorySegment seg, int x) {
-        constants$6.const$0.set(seg, x);
-    }
-    public static int proto_minor$get(MemorySegment seg, long index) {
-        return (int)constants$6.const$0.get(seg.asSlice(index*sizeof()));
+    public static void proto_minor(MemorySegment struct, int fieldValue) {
+        struct.set(proto_minor$LAYOUT, proto_minor$OFFSET, fieldValue);
     }
-    public static void proto_minor$set(MemorySegment seg, long index, int x) {
-        constants$6.const$0.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt max_write$LAYOUT = (OfInt)$LAYOUT.select(groupElement("max_write"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * unsigned int max_write
+     * }
+     */
+    public static final OfInt max_write$layout() {
+        return max_write$LAYOUT;
     }
-    public static VarHandle max_write$VH() {
-        return constants$6.const$1;
+
+    private static final long max_write$OFFSET = 8;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * unsigned int max_write
+     * }
+     */
+    public static final long max_write$offset() {
+        return max_write$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned int max_write;
+     * {@snippet lang=c :
+     * unsigned int max_write
      * }
      */
-    public static int max_write$get(MemorySegment seg) {
-        return (int)constants$6.const$1.get(seg);
+    public static int max_write(MemorySegment struct) {
+        return struct.get(max_write$LAYOUT, max_write$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned int max_write;
+     * {@snippet lang=c :
+     * unsigned int max_write
      * }
      */
-    public static void max_write$set(MemorySegment seg, int x) {
-        constants$6.const$1.set(seg, x);
-    }
-    public static int max_write$get(MemorySegment seg, long index) {
-        return (int)constants$6.const$1.get(seg.asSlice(index*sizeof()));
+    public static void max_write(MemorySegment struct, int fieldValue) {
+        struct.set(max_write$LAYOUT, max_write$OFFSET, fieldValue);
     }
-    public static void max_write$set(MemorySegment seg, long index, int x) {
-        constants$6.const$1.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt max_read$LAYOUT = (OfInt)$LAYOUT.select(groupElement("max_read"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * unsigned int max_read
+     * }
+     */
+    public static final OfInt max_read$layout() {
+        return max_read$LAYOUT;
     }
-    public static VarHandle max_read$VH() {
-        return constants$6.const$2;
+
+    private static final long max_read$OFFSET = 12;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * unsigned int max_read
+     * }
+     */
+    public static final long max_read$offset() {
+        return max_read$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned int max_read;
+     * {@snippet lang=c :
+     * unsigned int max_read
      * }
      */
-    public static int max_read$get(MemorySegment seg) {
-        return (int)constants$6.const$2.get(seg);
+    public static int max_read(MemorySegment struct) {
+        return struct.get(max_read$LAYOUT, max_read$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned int max_read;
+     * {@snippet lang=c :
+     * unsigned int max_read
      * }
      */
-    public static void max_read$set(MemorySegment seg, int x) {
-        constants$6.const$2.set(seg, x);
-    }
-    public static int max_read$get(MemorySegment seg, long index) {
-        return (int)constants$6.const$2.get(seg.asSlice(index*sizeof()));
+    public static void max_read(MemorySegment struct, int fieldValue) {
+        struct.set(max_read$LAYOUT, max_read$OFFSET, fieldValue);
     }
-    public static void max_read$set(MemorySegment seg, long index, int x) {
-        constants$6.const$2.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt max_readahead$LAYOUT = (OfInt)$LAYOUT.select(groupElement("max_readahead"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * unsigned int max_readahead
+     * }
+     */
+    public static final OfInt max_readahead$layout() {
+        return max_readahead$LAYOUT;
     }
-    public static VarHandle max_readahead$VH() {
-        return constants$6.const$3;
+
+    private static final long max_readahead$OFFSET = 16;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * unsigned int max_readahead
+     * }
+     */
+    public static final long max_readahead$offset() {
+        return max_readahead$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned int max_readahead;
+     * {@snippet lang=c :
+     * unsigned int max_readahead
      * }
      */
-    public static int max_readahead$get(MemorySegment seg) {
-        return (int)constants$6.const$3.get(seg);
+    public static int max_readahead(MemorySegment struct) {
+        return struct.get(max_readahead$LAYOUT, max_readahead$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned int max_readahead;
+     * {@snippet lang=c :
+     * unsigned int max_readahead
      * }
      */
-    public static void max_readahead$set(MemorySegment seg, int x) {
-        constants$6.const$3.set(seg, x);
+    public static void max_readahead(MemorySegment struct, int fieldValue) {
+        struct.set(max_readahead$LAYOUT, max_readahead$OFFSET, fieldValue);
     }
-    public static int max_readahead$get(MemorySegment seg, long index) {
-        return (int)constants$6.const$3.get(seg.asSlice(index*sizeof()));
-    }
-    public static void max_readahead$set(MemorySegment seg, long index, int x) {
-        constants$6.const$3.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt capable$LAYOUT = (OfInt)$LAYOUT.select(groupElement("capable"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * unsigned int capable
+     * }
+     */
+    public static final OfInt capable$layout() {
+        return capable$LAYOUT;
     }
-    public static VarHandle capable$VH() {
-        return constants$6.const$4;
+
+    private static final long capable$OFFSET = 20;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * unsigned int capable
+     * }
+     */
+    public static final long capable$offset() {
+        return capable$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned int capable;
+     * {@snippet lang=c :
+     * unsigned int capable
      * }
      */
-    public static int capable$get(MemorySegment seg) {
-        return (int)constants$6.const$4.get(seg);
+    public static int capable(MemorySegment struct) {
+        return struct.get(capable$LAYOUT, capable$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned int capable;
+     * {@snippet lang=c :
+     * unsigned int capable
      * }
      */
-    public static void capable$set(MemorySegment seg, int x) {
-        constants$6.const$4.set(seg, x);
-    }
-    public static int capable$get(MemorySegment seg, long index) {
-        return (int)constants$6.const$4.get(seg.asSlice(index*sizeof()));
+    public static void capable(MemorySegment struct, int fieldValue) {
+        struct.set(capable$LAYOUT, capable$OFFSET, fieldValue);
     }
-    public static void capable$set(MemorySegment seg, long index, int x) {
-        constants$6.const$4.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt want$LAYOUT = (OfInt)$LAYOUT.select(groupElement("want"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * unsigned int want
+     * }
+     */
+    public static final OfInt want$layout() {
+        return want$LAYOUT;
     }
-    public static VarHandle want$VH() {
-        return constants$6.const$5;
+
+    private static final long want$OFFSET = 24;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * unsigned int want
+     * }
+     */
+    public static final long want$offset() {
+        return want$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned int want;
+     * {@snippet lang=c :
+     * unsigned int want
      * }
      */
-    public static int want$get(MemorySegment seg) {
-        return (int)constants$6.const$5.get(seg);
+    public static int want(MemorySegment struct) {
+        return struct.get(want$LAYOUT, want$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned int want;
+     * {@snippet lang=c :
+     * unsigned int want
      * }
      */
-    public static void want$set(MemorySegment seg, int x) {
-        constants$6.const$5.set(seg, x);
+    public static void want(MemorySegment struct, int fieldValue) {
+        struct.set(want$LAYOUT, want$OFFSET, fieldValue);
     }
-    public static int want$get(MemorySegment seg, long index) {
-        return (int)constants$6.const$5.get(seg.asSlice(index*sizeof()));
-    }
-    public static void want$set(MemorySegment seg, long index, int x) {
-        constants$6.const$5.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt max_background$LAYOUT = (OfInt)$LAYOUT.select(groupElement("max_background"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * unsigned int max_background
+     * }
+     */
+    public static final OfInt max_background$layout() {
+        return max_background$LAYOUT;
     }
-    public static VarHandle max_background$VH() {
-        return constants$7.const$0;
+
+    private static final long max_background$OFFSET = 28;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * unsigned int max_background
+     * }
+     */
+    public static final long max_background$offset() {
+        return max_background$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned int max_background;
+     * {@snippet lang=c :
+     * unsigned int max_background
      * }
      */
-    public static int max_background$get(MemorySegment seg) {
-        return (int)constants$7.const$0.get(seg);
+    public static int max_background(MemorySegment struct) {
+        return struct.get(max_background$LAYOUT, max_background$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned int max_background;
+     * {@snippet lang=c :
+     * unsigned int max_background
      * }
      */
-    public static void max_background$set(MemorySegment seg, int x) {
-        constants$7.const$0.set(seg, x);
-    }
-    public static int max_background$get(MemorySegment seg, long index) {
-        return (int)constants$7.const$0.get(seg.asSlice(index*sizeof()));
+    public static void max_background(MemorySegment struct, int fieldValue) {
+        struct.set(max_background$LAYOUT, max_background$OFFSET, fieldValue);
     }
-    public static void max_background$set(MemorySegment seg, long index, int x) {
-        constants$7.const$0.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt congestion_threshold$LAYOUT = (OfInt)$LAYOUT.select(groupElement("congestion_threshold"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * unsigned int congestion_threshold
+     * }
+     */
+    public static final OfInt congestion_threshold$layout() {
+        return congestion_threshold$LAYOUT;
     }
-    public static VarHandle congestion_threshold$VH() {
-        return constants$7.const$1;
+
+    private static final long congestion_threshold$OFFSET = 32;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * unsigned int congestion_threshold
+     * }
+     */
+    public static final long congestion_threshold$offset() {
+        return congestion_threshold$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned int congestion_threshold;
+     * {@snippet lang=c :
+     * unsigned int congestion_threshold
      * }
      */
-    public static int congestion_threshold$get(MemorySegment seg) {
-        return (int)constants$7.const$1.get(seg);
+    public static int congestion_threshold(MemorySegment struct) {
+        return struct.get(congestion_threshold$LAYOUT, congestion_threshold$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned int congestion_threshold;
+     * {@snippet lang=c :
+     * unsigned int congestion_threshold
      * }
      */
-    public static void congestion_threshold$set(MemorySegment seg, int x) {
-        constants$7.const$1.set(seg, x);
+    public static void congestion_threshold(MemorySegment struct, int fieldValue) {
+        struct.set(congestion_threshold$LAYOUT, congestion_threshold$OFFSET, fieldValue);
     }
-    public static int congestion_threshold$get(MemorySegment seg, long index) {
-        return (int)constants$7.const$1.get(seg.asSlice(index*sizeof()));
+
+    private static final OfInt time_gran$LAYOUT = (OfInt)$LAYOUT.select(groupElement("time_gran"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * unsigned int time_gran
+     * }
+     */
+    public static final OfInt time_gran$layout() {
+        return time_gran$LAYOUT;
     }
-    public static void congestion_threshold$set(MemorySegment seg, long index, int x) {
-        constants$7.const$1.set(seg.asSlice(index*sizeof()), x);
+
+    private static final long time_gran$OFFSET = 36;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * unsigned int time_gran
+     * }
+     */
+    public static final long time_gran$offset() {
+        return time_gran$OFFSET;
     }
-    public static VarHandle time_gran$VH() {
-        return constants$7.const$2;
+
+    /**
+     * Getter for field:
+     * {@snippet lang=c :
+     * unsigned int time_gran
+     * }
+     */
+    public static int time_gran(MemorySegment struct) {
+        return struct.get(time_gran$LAYOUT, time_gran$OFFSET);
     }
+
+    /**
+     * Setter for field:
+     * {@snippet lang=c :
+     * unsigned int time_gran
+     * }
+     */
+    public static void time_gran(MemorySegment struct, int fieldValue) {
+        struct.set(time_gran$LAYOUT, time_gran$OFFSET, fieldValue);
+    }
+
+    private static final SequenceLayout reserved$LAYOUT = (SequenceLayout)$LAYOUT.select(groupElement("reserved"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * unsigned int reserved[22]
+     * }
+     */
+    public static final SequenceLayout reserved$layout() {
+        return reserved$LAYOUT;
+    }
+
+    private static final long reserved$OFFSET = 40;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * unsigned int reserved[22]
+     * }
+     */
+    public static final long reserved$offset() {
+        return reserved$OFFSET;
+    }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned int time_gran;
+     * {@snippet lang=c :
+     * unsigned int reserved[22]
      * }
      */
-    public static int time_gran$get(MemorySegment seg) {
-        return (int)constants$7.const$2.get(seg);
+    public static MemorySegment reserved(MemorySegment struct) {
+        return struct.asSlice(reserved$OFFSET, reserved$LAYOUT.byteSize());
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned int time_gran;
+     * {@snippet lang=c :
+     * unsigned int reserved[22]
      * }
      */
-    public static void time_gran$set(MemorySegment seg, int x) {
-        constants$7.const$2.set(seg, x);
+    public static void reserved(MemorySegment struct, MemorySegment fieldValue) {
+        MemorySegment.copy(fieldValue, 0L, struct, reserved$OFFSET, reserved$LAYOUT.byteSize());
     }
-    public static int time_gran$get(MemorySegment seg, long index) {
-        return (int)constants$7.const$2.get(seg.asSlice(index*sizeof()));
+
+    private static long[] reserved$DIMS = { 22 };
+
+    /**
+     * Dimensions for array field:
+     * {@snippet lang=c :
+     * unsigned int reserved[22]
+     * }
+     */
+    public static long[] reserved$dimensions() {
+        return reserved$DIMS;
     }
-    public static void time_gran$set(MemorySegment seg, long index, int x) {
-        constants$7.const$2.set(seg.asSlice(index*sizeof()), x);
+    private static final VarHandle reserved$ELEM_HANDLE = reserved$LAYOUT.varHandle(sequenceElement());
+
+    /**
+     * Indexed getter for field:
+     * {@snippet lang=c :
+     * unsigned int reserved[22]
+     * }
+     */
+    public static int reserved(MemorySegment struct, long index0) {
+        return (int)reserved$ELEM_HANDLE.get(struct, 0L, index0);
     }
-    public static MemorySegment reserved$slice(MemorySegment seg) {
-        return seg.asSlice(40, 88);
+
+    /**
+     * Indexed setter for field:
+     * {@snippet lang=c :
+     * unsigned int reserved[22]
+     * }
+     */
+    public static void reserved(MemorySegment struct, long index0, int fieldValue) {
+        reserved$ELEM_HANDLE.set(struct, 0L, index0, fieldValue);
     }
-    public static long sizeof() { return $LAYOUT().byteSize(); }
-    public static MemorySegment allocate(SegmentAllocator allocator) { return allocator.allocate($LAYOUT()); }
-    public static MemorySegment allocateArray(long len, SegmentAllocator allocator) {
-        return allocator.allocate(MemoryLayout.sequenceLayout(len, $LAYOUT()));
+
+    /**
+     * Obtains a slice of {@code arrayParam} which selects the array element at {@code index}.
+     * The returned segment has address {@code arrayParam.address() + index * layout().byteSize()}
+     */
+    public static MemorySegment asSlice(MemorySegment array, long index) {
+        return array.asSlice(layout().byteSize() * index);
+    }
+
+    /**
+     * The size (in bytes) of this struct
+     */
+    public static long sizeof() { return layout().byteSize(); }
+
+    /**
+     * Allocate a segment of size {@code layout().byteSize()} using {@code allocator}
+     */
+    public static MemorySegment allocate(SegmentAllocator allocator) {
+        return allocator.allocate(layout());
     }
-    public static MemorySegment ofAddress(MemorySegment addr, Arena scope) { return RuntimeHelper.asArray(addr, $LAYOUT(), 1, scope); }
-}
 
+    /**
+     * Allocate an array of size {@code elementCount} using {@code allocator}.
+     * The returned segment has size {@code elementCount * layout().byteSize()}.
+     */
+    public static MemorySegment allocateArray(long elementCount, SegmentAllocator allocator) {
+        return allocator.allocate(MemoryLayout.sequenceLayout(elementCount, layout()));
+    }
+
+    /**
+     * Reinterprets {@code addr} using target {@code arena} and {@code cleanupAction) (if any).
+     * The returned segment has size {@code layout().byteSize()}
+     */
+    public static MemorySegment reinterpret(MemorySegment addr, Arena arena, Consumer<MemorySegment> cleanup) {
+        return reinterpret(addr, 1, arena, cleanup);
+    }
+
+    /**
+     * Reinterprets {@code addr} using target {@code arena} and {@code cleanupAction) (if any).
+     * The returned segment has size {@code elementCount * layout().byteSize()}
+     */
+    public static MemorySegment reinterpret(MemorySegment addr, long elementCount, Arena arena, Consumer<MemorySegment> cleanup) {
+        return addr.reinterpret(layout().byteSize() * elementCount, arena, cleanup);
+    }
+}
 
diff --git a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/fuse3_file_info.java b/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/fuse3_file_info.java
index ce028fb9..c5677101 100644
--- a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/fuse3_file_info.java
+++ b/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/fuse3_file_info.java
@@ -2,147 +2,273 @@
 
 package org.cryptomator.jfuse.win.extr.fuse3;
 
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
+import java.lang.invoke.*;
 import java.lang.foreign.*;
+import java.nio.ByteOrder;
+import java.util.*;
+import java.util.function.*;
+import java.util.stream.*;
+
 import static java.lang.foreign.ValueLayout.*;
+import static java.lang.foreign.MemoryLayout.PathElement.*;
+
 /**
- * {@snippet :
+ * {@snippet lang=c :
  * struct fuse3_file_info {
  *     int flags;
- *      *     unsigned int writepage;
- *     unsigned int direct_io;
- *     unsigned int keep_cache;
- *     unsigned int flush;
- *     unsigned int nonseekable;
- *     unsigned int flock_release;
- *     unsigned int padding;
- *     unsigned long long fh;
- *     unsigned long long lock_owner;
- *     unsigned int poll_events;
- * };
+ *     unsigned int writepage : 1;
+ *     unsigned int direct_io : 1;
+ *     unsigned int keep_cache : 1;
+ *     unsigned int flush : 1;
+ *     unsigned int nonseekable : 1;
+ *     unsigned int flock_release : 1;
+ *     unsigned int padding : 27;
+ *     uint64_t fh;
+ *     uint64_t lock_owner;
+ *     uint32_t poll_events;
+ * }
  * }
  */
 public class fuse3_file_info {
 
-    public static MemoryLayout $LAYOUT() {
-        return constants$4.const$2;
+    fuse3_file_info() {
+        // Should not be called directly
     }
-    public static VarHandle flags$VH() {
-        return constants$4.const$3;
+
+    private static final GroupLayout $LAYOUT = MemoryLayout.structLayout(
+        fuse_h.C_INT.withName("flags"),
+        MemoryLayout.paddingLayout(12),
+        fuse_h.C_LONG_LONG.withName("fh"),
+        fuse_h.C_LONG_LONG.withName("lock_owner"),
+        fuse_h.C_INT.withName("poll_events"),
+        MemoryLayout.paddingLayout(4)
+    ).withName("fuse3_file_info");
+
+    /**
+     * The layout of this struct
+     */
+    public static final GroupLayout layout() {
+        return $LAYOUT;
+    }
+
+    private static final OfInt flags$LAYOUT = (OfInt)$LAYOUT.select(groupElement("flags"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int flags
+     * }
+     */
+    public static final OfInt flags$layout() {
+        return flags$LAYOUT;
+    }
+
+    private static final long flags$OFFSET = 0;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int flags
+     * }
+     */
+    public static final long flags$offset() {
+        return flags$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int flags;
+     * {@snippet lang=c :
+     * int flags
      * }
      */
-    public static int flags$get(MemorySegment seg) {
-        return (int)constants$4.const$3.get(seg);
+    public static int flags(MemorySegment struct) {
+        return struct.get(flags$LAYOUT, flags$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int flags;
+     * {@snippet lang=c :
+     * int flags
      * }
      */
-    public static void flags$set(MemorySegment seg, int x) {
-        constants$4.const$3.set(seg, x);
-    }
-    public static int flags$get(MemorySegment seg, long index) {
-        return (int)constants$4.const$3.get(seg.asSlice(index*sizeof()));
+    public static void flags(MemorySegment struct, int fieldValue) {
+        struct.set(flags$LAYOUT, flags$OFFSET, fieldValue);
     }
-    public static void flags$set(MemorySegment seg, long index, int x) {
-        constants$4.const$3.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfLong fh$LAYOUT = (OfLong)$LAYOUT.select(groupElement("fh"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * uint64_t fh
+     * }
+     */
+    public static final OfLong fh$layout() {
+        return fh$LAYOUT;
     }
-    public static VarHandle fh$VH() {
-        return constants$4.const$4;
+
+    private static final long fh$OFFSET = 16;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * uint64_t fh
+     * }
+     */
+    public static final long fh$offset() {
+        return fh$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned long long fh;
+     * {@snippet lang=c :
+     * uint64_t fh
      * }
      */
-    public static long fh$get(MemorySegment seg) {
-        return (long)constants$4.const$4.get(seg);
+    public static long fh(MemorySegment struct) {
+        return struct.get(fh$LAYOUT, fh$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned long long fh;
+     * {@snippet lang=c :
+     * uint64_t fh
      * }
      */
-    public static void fh$set(MemorySegment seg, long x) {
-        constants$4.const$4.set(seg, x);
-    }
-    public static long fh$get(MemorySegment seg, long index) {
-        return (long)constants$4.const$4.get(seg.asSlice(index*sizeof()));
+    public static void fh(MemorySegment struct, long fieldValue) {
+        struct.set(fh$LAYOUT, fh$OFFSET, fieldValue);
     }
-    public static void fh$set(MemorySegment seg, long index, long x) {
-        constants$4.const$4.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfLong lock_owner$LAYOUT = (OfLong)$LAYOUT.select(groupElement("lock_owner"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * uint64_t lock_owner
+     * }
+     */
+    public static final OfLong lock_owner$layout() {
+        return lock_owner$LAYOUT;
     }
-    public static VarHandle lock_owner$VH() {
-        return constants$4.const$5;
+
+    private static final long lock_owner$OFFSET = 24;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * uint64_t lock_owner
+     * }
+     */
+    public static final long lock_owner$offset() {
+        return lock_owner$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned long long lock_owner;
+     * {@snippet lang=c :
+     * uint64_t lock_owner
      * }
      */
-    public static long lock_owner$get(MemorySegment seg) {
-        return (long)constants$4.const$5.get(seg);
+    public static long lock_owner(MemorySegment struct) {
+        return struct.get(lock_owner$LAYOUT, lock_owner$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned long long lock_owner;
+     * {@snippet lang=c :
+     * uint64_t lock_owner
      * }
      */
-    public static void lock_owner$set(MemorySegment seg, long x) {
-        constants$4.const$5.set(seg, x);
-    }
-    public static long lock_owner$get(MemorySegment seg, long index) {
-        return (long)constants$4.const$5.get(seg.asSlice(index*sizeof()));
+    public static void lock_owner(MemorySegment struct, long fieldValue) {
+        struct.set(lock_owner$LAYOUT, lock_owner$OFFSET, fieldValue);
     }
-    public static void lock_owner$set(MemorySegment seg, long index, long x) {
-        constants$4.const$5.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt poll_events$LAYOUT = (OfInt)$LAYOUT.select(groupElement("poll_events"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * uint32_t poll_events
+     * }
+     */
+    public static final OfInt poll_events$layout() {
+        return poll_events$LAYOUT;
     }
-    public static VarHandle poll_events$VH() {
-        return constants$5.const$0;
+
+    private static final long poll_events$OFFSET = 32;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * uint32_t poll_events
+     * }
+     */
+    public static final long poll_events$offset() {
+        return poll_events$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned int poll_events;
+     * {@snippet lang=c :
+     * uint32_t poll_events
      * }
      */
-    public static int poll_events$get(MemorySegment seg) {
-        return (int)constants$5.const$0.get(seg);
+    public static int poll_events(MemorySegment struct) {
+        return struct.get(poll_events$LAYOUT, poll_events$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned int poll_events;
+     * {@snippet lang=c :
+     * uint32_t poll_events
      * }
      */
-    public static void poll_events$set(MemorySegment seg, int x) {
-        constants$5.const$0.set(seg, x);
+    public static void poll_events(MemorySegment struct, int fieldValue) {
+        struct.set(poll_events$LAYOUT, poll_events$OFFSET, fieldValue);
     }
-    public static int poll_events$get(MemorySegment seg, long index) {
-        return (int)constants$5.const$0.get(seg.asSlice(index*sizeof()));
+
+    /**
+     * Obtains a slice of {@code arrayParam} which selects the array element at {@code index}.
+     * The returned segment has address {@code arrayParam.address() + index * layout().byteSize()}
+     */
+    public static MemorySegment asSlice(MemorySegment array, long index) {
+        return array.asSlice(layout().byteSize() * index);
+    }
+
+    /**
+     * The size (in bytes) of this struct
+     */
+    public static long sizeof() { return layout().byteSize(); }
+
+    /**
+     * Allocate a segment of size {@code layout().byteSize()} using {@code allocator}
+     */
+    public static MemorySegment allocate(SegmentAllocator allocator) {
+        return allocator.allocate(layout());
+    }
+
+    /**
+     * Allocate an array of size {@code elementCount} using {@code allocator}.
+     * The returned segment has size {@code elementCount * layout().byteSize()}.
+     */
+    public static MemorySegment allocateArray(long elementCount, SegmentAllocator allocator) {
+        return allocator.allocate(MemoryLayout.sequenceLayout(elementCount, layout()));
     }
-    public static void poll_events$set(MemorySegment seg, long index, int x) {
-        constants$5.const$0.set(seg.asSlice(index*sizeof()), x);
+
+    /**
+     * Reinterprets {@code addr} using target {@code arena} and {@code cleanupAction) (if any).
+     * The returned segment has size {@code layout().byteSize()}
+     */
+    public static MemorySegment reinterpret(MemorySegment addr, Arena arena, Consumer<MemorySegment> cleanup) {
+        return reinterpret(addr, 1, arena, cleanup);
     }
-    public static long sizeof() { return $LAYOUT().byteSize(); }
-    public static MemorySegment allocate(SegmentAllocator allocator) { return allocator.allocate($LAYOUT()); }
-    public static MemorySegment allocateArray(long len, SegmentAllocator allocator) {
-        return allocator.allocate(MemoryLayout.sequenceLayout(len, $LAYOUT()));
+
+    /**
+     * Reinterprets {@code addr} using target {@code arena} and {@code cleanupAction) (if any).
+     * The returned segment has size {@code elementCount * layout().byteSize()}
+     */
+    public static MemorySegment reinterpret(MemorySegment addr, long elementCount, Arena arena, Consumer<MemorySegment> cleanup) {
+        return addr.reinterpret(layout().byteSize() * elementCount, arena, cleanup);
     }
-    public static MemorySegment ofAddress(MemorySegment addr, Arena scope) { return RuntimeHelper.asArray(addr, $LAYOUT(), 1, scope); }
 }
 
-
diff --git a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/fuse3_fill_dir_t.java b/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/fuse3_fill_dir_t.java
index 8fde60fa..e7d13e30 100644
--- a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/fuse3_fill_dir_t.java
+++ b/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/fuse3_fill_dir_t.java
@@ -2,32 +2,88 @@
 
 package org.cryptomator.jfuse.win.extr.fuse3;
 
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
+import java.lang.invoke.*;
 import java.lang.foreign.*;
+import java.nio.ByteOrder;
+import java.util.*;
+import java.util.function.*;
+import java.util.stream.*;
+
 import static java.lang.foreign.ValueLayout.*;
+import static java.lang.foreign.MemoryLayout.PathElement.*;
+
 /**
- * {@snippet :
- * int (*fuse3_fill_dir_t)(void* buf,char* name,struct fuse_stat* stbuf,long long off,enum fuse3_fill_dir_flags flags);
+ * {@snippet lang=c :
+ * typedef int (*fuse3_fill_dir_t)(void *, const char *, const struct fuse_stat {
+ *     fuse_dev_t st_dev;
+ *     fuse_ino_t st_ino;
+ *     fuse_mode_t st_mode;
+ *     fuse_nlink_t st_nlink;
+ *     fuse_uid_t st_uid;
+ *     fuse_gid_t st_gid;
+ *     fuse_dev_t st_rdev;
+ *     fuse_off_t st_size;
+ *     struct fuse_timespec st_atim;
+ *     struct fuse_timespec st_mtim;
+ *     struct fuse_timespec st_ctim;
+ *     fuse_blksize_t st_blksize;
+ *     fuse_blkcnt_t st_blocks;
+ *     struct fuse_timespec st_birthtim;
+ * } *, fuse_off_t, enum fuse3_fill_dir_flags {
+ *     FUSE_FILL_DIR_PLUS = (1 << 1)
+ * })
  * }
  */
-public interface fuse3_fill_dir_t {
+public class fuse3_fill_dir_t {
 
-    int apply(java.lang.foreign.MemorySegment buf, java.lang.foreign.MemorySegment name, java.lang.foreign.MemorySegment stbuf, long off, int flags);
-    static MemorySegment allocate(fuse3_fill_dir_t fi, Arena scope) {
-        return RuntimeHelper.upcallStub(constants$7.const$4, fi, constants$7.const$3, scope);
+    fuse3_fill_dir_t() {
+        // Should not be called directly
     }
-    static fuse3_fill_dir_t ofAddress(MemorySegment addr, Arena arena) {
-        MemorySegment symbol = addr.reinterpret(arena, null);
-        return (java.lang.foreign.MemorySegment _buf, java.lang.foreign.MemorySegment _name, java.lang.foreign.MemorySegment _stbuf, long _off, int _flags) -> {
-            try {
-                return (int)constants$7.const$5.invokeExact(symbol, _buf, _name, _stbuf, _off, _flags);
-            } catch (Throwable ex$) {
-                throw new AssertionError("should not reach here", ex$);
-            }
-        };
+
+    /**
+     * The function pointer signature, expressed as a functional interface
+     */
+    public interface Function {
+        int apply(MemorySegment buf, MemorySegment name, MemorySegment stbuf, long off, int flags);
     }
-}
 
+    private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+        fuse_h.C_INT,
+        fuse_h.C_POINTER,
+        fuse_h.C_POINTER,
+        fuse_h.C_POINTER,
+        fuse_h.C_LONG_LONG,
+        fuse_h.C_INT
+    );
+
+    /**
+     * The descriptor of this function pointer
+     */
+    public static FunctionDescriptor descriptor() {
+        return $DESC;
+    }
+
+    private static final MethodHandle UP$MH = fuse_h.upcallHandle(fuse3_fill_dir_t.Function.class, "apply", $DESC);
+
+    /**
+     * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+     * The lifetime of the returned segment is managed by {@code arena}
+     */
+    public static MemorySegment allocate(fuse3_fill_dir_t.Function fi, Arena arena) {
+        return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+    }
+
+    private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+    /**
+     * Invoke the upcall stub {@code funcPtr}, with given parameters
+     */
+    public static int invoke(MemorySegment funcPtr,MemorySegment buf, MemorySegment name, MemorySegment stbuf, long off, int flags) {
+        try {
+            return (int) DOWN$MH.invokeExact(funcPtr, buf, name, stbuf, off, flags);
+        } catch (Throwable ex$) {
+            throw new AssertionError("should not reach here", ex$);
+        }
+    }
+}
 
diff --git a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/fuse3_loop_config.java b/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/fuse3_loop_config.java
index f324be86..05d35194 100644
--- a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/fuse3_loop_config.java
+++ b/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/fuse3_loop_config.java
@@ -2,84 +2,172 @@
 
 package org.cryptomator.jfuse.win.extr.fuse3;
 
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
+import java.lang.invoke.*;
 import java.lang.foreign.*;
+import java.nio.ByteOrder;
+import java.util.*;
+import java.util.function.*;
+import java.util.stream.*;
+
 import static java.lang.foreign.ValueLayout.*;
+import static java.lang.foreign.MemoryLayout.PathElement.*;
+
 /**
- * {@snippet :
+ * {@snippet lang=c :
  * struct fuse3_loop_config {
  *     int clone_fd;
  *     unsigned int max_idle_threads;
- * };
+ * }
  * }
  */
 public class fuse3_loop_config {
 
-    public static MemoryLayout $LAYOUT() {
-        return constants$5.const$1;
+    fuse3_loop_config() {
+        // Should not be called directly
     }
-    public static VarHandle clone_fd$VH() {
-        return constants$5.const$2;
+
+    private static final GroupLayout $LAYOUT = MemoryLayout.structLayout(
+        fuse_h.C_INT.withName("clone_fd"),
+        fuse_h.C_INT.withName("max_idle_threads")
+    ).withName("fuse3_loop_config");
+
+    /**
+     * The layout of this struct
+     */
+    public static final GroupLayout layout() {
+        return $LAYOUT;
     }
+
+    private static final OfInt clone_fd$LAYOUT = (OfInt)$LAYOUT.select(groupElement("clone_fd"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int clone_fd
+     * }
+     */
+    public static final OfInt clone_fd$layout() {
+        return clone_fd$LAYOUT;
+    }
+
+    private static final long clone_fd$OFFSET = 0;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int clone_fd
+     * }
+     */
+    public static final long clone_fd$offset() {
+        return clone_fd$OFFSET;
+    }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int clone_fd;
+     * {@snippet lang=c :
+     * int clone_fd
      * }
      */
-    public static int clone_fd$get(MemorySegment seg) {
-        return (int)constants$5.const$2.get(seg);
+    public static int clone_fd(MemorySegment struct) {
+        return struct.get(clone_fd$LAYOUT, clone_fd$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int clone_fd;
+     * {@snippet lang=c :
+     * int clone_fd
      * }
      */
-    public static void clone_fd$set(MemorySegment seg, int x) {
-        constants$5.const$2.set(seg, x);
-    }
-    public static int clone_fd$get(MemorySegment seg, long index) {
-        return (int)constants$5.const$2.get(seg.asSlice(index*sizeof()));
+    public static void clone_fd(MemorySegment struct, int fieldValue) {
+        struct.set(clone_fd$LAYOUT, clone_fd$OFFSET, fieldValue);
     }
-    public static void clone_fd$set(MemorySegment seg, long index, int x) {
-        constants$5.const$2.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt max_idle_threads$LAYOUT = (OfInt)$LAYOUT.select(groupElement("max_idle_threads"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * unsigned int max_idle_threads
+     * }
+     */
+    public static final OfInt max_idle_threads$layout() {
+        return max_idle_threads$LAYOUT;
     }
-    public static VarHandle max_idle_threads$VH() {
-        return constants$5.const$3;
+
+    private static final long max_idle_threads$OFFSET = 4;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * unsigned int max_idle_threads
+     * }
+     */
+    public static final long max_idle_threads$offset() {
+        return max_idle_threads$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned int max_idle_threads;
+     * {@snippet lang=c :
+     * unsigned int max_idle_threads
      * }
      */
-    public static int max_idle_threads$get(MemorySegment seg) {
-        return (int)constants$5.const$3.get(seg);
+    public static int max_idle_threads(MemorySegment struct) {
+        return struct.get(max_idle_threads$LAYOUT, max_idle_threads$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned int max_idle_threads;
+     * {@snippet lang=c :
+     * unsigned int max_idle_threads
      * }
      */
-    public static void max_idle_threads$set(MemorySegment seg, int x) {
-        constants$5.const$3.set(seg, x);
+    public static void max_idle_threads(MemorySegment struct, int fieldValue) {
+        struct.set(max_idle_threads$LAYOUT, max_idle_threads$OFFSET, fieldValue);
+    }
+
+    /**
+     * Obtains a slice of {@code arrayParam} which selects the array element at {@code index}.
+     * The returned segment has address {@code arrayParam.address() + index * layout().byteSize()}
+     */
+    public static MemorySegment asSlice(MemorySegment array, long index) {
+        return array.asSlice(layout().byteSize() * index);
+    }
+
+    /**
+     * The size (in bytes) of this struct
+     */
+    public static long sizeof() { return layout().byteSize(); }
+
+    /**
+     * Allocate a segment of size {@code layout().byteSize()} using {@code allocator}
+     */
+    public static MemorySegment allocate(SegmentAllocator allocator) {
+        return allocator.allocate(layout());
     }
-    public static int max_idle_threads$get(MemorySegment seg, long index) {
-        return (int)constants$5.const$3.get(seg.asSlice(index*sizeof()));
+
+    /**
+     * Allocate an array of size {@code elementCount} using {@code allocator}.
+     * The returned segment has size {@code elementCount * layout().byteSize()}.
+     */
+    public static MemorySegment allocateArray(long elementCount, SegmentAllocator allocator) {
+        return allocator.allocate(MemoryLayout.sequenceLayout(elementCount, layout()));
     }
-    public static void max_idle_threads$set(MemorySegment seg, long index, int x) {
-        constants$5.const$3.set(seg.asSlice(index*sizeof()), x);
+
+    /**
+     * Reinterprets {@code addr} using target {@code arena} and {@code cleanupAction) (if any).
+     * The returned segment has size {@code layout().byteSize()}
+     */
+    public static MemorySegment reinterpret(MemorySegment addr, Arena arena, Consumer<MemorySegment> cleanup) {
+        return reinterpret(addr, 1, arena, cleanup);
     }
-    public static long sizeof() { return $LAYOUT().byteSize(); }
-    public static MemorySegment allocate(SegmentAllocator allocator) { return allocator.allocate($LAYOUT()); }
-    public static MemorySegment allocateArray(long len, SegmentAllocator allocator) {
-        return allocator.allocate(MemoryLayout.sequenceLayout(len, $LAYOUT()));
+
+    /**
+     * Reinterprets {@code addr} using target {@code arena} and {@code cleanupAction) (if any).
+     * The returned segment has size {@code elementCount * layout().byteSize()}
+     */
+    public static MemorySegment reinterpret(MemorySegment addr, long elementCount, Arena arena, Consumer<MemorySegment> cleanup) {
+        return addr.reinterpret(layout().byteSize() * elementCount, arena, cleanup);
     }
-    public static MemorySegment ofAddress(MemorySegment addr, Arena scope) { return RuntimeHelper.asArray(addr, $LAYOUT(), 1, scope); }
 }
 
-
diff --git a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/fuse3_operations.java b/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/fuse3_operations.java
index 6fab8fcd..b9f06d18 100644
--- a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/fuse3_operations.java
+++ b/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/fuse3_operations.java
@@ -2,2188 +2,4162 @@
 
 package org.cryptomator.jfuse.win.extr.fuse3;
 
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
+import java.lang.invoke.*;
 import java.lang.foreign.*;
+import java.nio.ByteOrder;
+import java.util.*;
+import java.util.function.*;
+import java.util.stream.*;
+
 import static java.lang.foreign.ValueLayout.*;
+import static java.lang.foreign.MemoryLayout.PathElement.*;
+
 /**
- * {@snippet :
+ * {@snippet lang=c :
  * struct fuse3_operations {
- *     int (*getattr)(char*,struct fuse_stat*,struct fuse3_file_info*);
- *     int (*readlink)(char*,char*,unsigned long long);
- *     int (*mknod)(char*,unsigned int,unsigned int);
- *     int (*mkdir)(char*,unsigned int);
- *     int (*unlink)(char*);
- *     int (*rmdir)(char*);
- *     int (*symlink)(char*,char*);
- *     int (*rename)(char*,char*,unsigned int);
- *     int (*link)(char*,char*);
- *     int (*chmod)(char*,unsigned int,struct fuse3_file_info*);
- *     int (*chown)(char*,unsigned int,unsigned int,struct fuse3_file_info*);
- *     int (*truncate)(char*,long long,struct fuse3_file_info*);
- *     int (*open)(char*,struct fuse3_file_info*);
- *     int (*read)(char*,char*,unsigned long long,long long,struct fuse3_file_info*);
- *     int (*write)(char*,char*,unsigned long long,long long,struct fuse3_file_info*);
- *     int (*statfs)(char*,struct fuse_statvfs*);
- *     int (*flush)(char*,struct fuse3_file_info*);
- *     int (*release)(char*,struct fuse3_file_info*);
- *     int (*fsync)(char*,int,struct fuse3_file_info*);
- *     int (*setxattr)(char*,char*,char*,unsigned long long,int);
- *     int (*getxattr)(char*,char*,char*,unsigned long long);
- *     int (*listxattr)(char*,char*,unsigned long long);
- *     int (*removexattr)(char*,char*);
- *     int (*opendir)(char*,struct fuse3_file_info*);
- *     int (*readdir)(char*,void*,int (*)(void*,char*,struct fuse_stat*,long long,enum fuse3_fill_dir_flags),long long,struct fuse3_file_info*,enum fuse3_readdir_flags);
- *     int (*releasedir)(char*,struct fuse3_file_info*);
- *     int (*fsyncdir)(char*,int,struct fuse3_file_info*);
- *     void* (*init)(struct fuse3_conn_info*,struct fuse3_config*);
- *     void (*destroy)(void*);
- *     int (*access)(char*,int);
- *     int (*create)(char*,unsigned int,struct fuse3_file_info*);
- *     int (*lock)(char*,struct fuse3_file_info*,int,struct fuse_flock*);
- *     int (*utimens)(char*,struct fuse_timespec*,struct fuse3_file_info*);
- *     int (*bmap)(char*,unsigned long long,unsigned long long*);
- *     int (*ioctl)(char*,int,void*,struct fuse3_file_info*,unsigned int,void*);
- *     int (*poll)(char*,struct fuse3_file_info*,struct fuse3_pollhandle*,unsigned int*);
- *     int (*write_buf)(char*,struct fuse3_bufvec*,long long,struct fuse3_file_info*);
- *     int (*read_buf)(char*,struct fuse3_bufvec**,unsigned long long,long long,struct fuse3_file_info*);
- *     int (*flock)(char*,struct fuse3_file_info*,int);
- *     int (*fallocate)(char*,int,long long,long long,struct fuse3_file_info*);
- * };
+ *     int (*getattr)(const char *, struct fuse_stat *, struct fuse3_file_info *);
+ *     int (*readlink)(const char *, char *, size_t);
+ *     int (*mknod)(const char *, fuse_mode_t, fuse_dev_t);
+ *     int (*mkdir)(const char *, fuse_mode_t);
+ *     int (*unlink)(const char *);
+ *     int (*rmdir)(const char *);
+ *     int (*symlink)(const char *, const char *);
+ *     int (*rename)(const char *, const char *, unsigned int);
+ *     int (*link)(const char *, const char *);
+ *     int (*chmod)(const char *, fuse_mode_t, struct fuse3_file_info *);
+ *     int (*chown)(const char *, fuse_uid_t, fuse_gid_t, struct fuse3_file_info *);
+ *     int (*truncate)(const char *, fuse_off_t, struct fuse3_file_info *);
+ *     int (*open)(const char *, struct fuse3_file_info *);
+ *     int (*read)(const char *, char *, size_t, fuse_off_t, struct fuse3_file_info *);
+ *     int (*write)(const char *, const char *, size_t, fuse_off_t, struct fuse3_file_info *);
+ *     int (*statfs)(const char *, struct fuse_statvfs *);
+ *     int (*flush)(const char *, struct fuse3_file_info *);
+ *     int (*release)(const char *, struct fuse3_file_info *);
+ *     int (*fsync)(const char *, int, struct fuse3_file_info *);
+ *     int (*setxattr)(const char *, const char *, const char *, size_t, int);
+ *     int (*getxattr)(const char *, const char *, char *, size_t);
+ *     int (*listxattr)(const char *, char *, size_t);
+ *     int (*removexattr)(const char *, const char *);
+ *     int (*opendir)(const char *, struct fuse3_file_info *);
+ *     int (*readdir)(const char *, void *, fuse3_fill_dir_t, fuse_off_t, struct fuse3_file_info *, enum fuse3_readdir_flags);
+ *     int (*releasedir)(const char *, struct fuse3_file_info *);
+ *     int (*fsyncdir)(const char *, int, struct fuse3_file_info *);
+ *     void *(*init)(struct fuse3_conn_info *, struct fuse3_config *);
+ *     void (*destroy)(void *);
+ *     int (*access)(const char *, int);
+ *     int (*create)(const char *, fuse_mode_t, struct fuse3_file_info *);
+ *     int (*lock)(const char *, struct fuse3_file_info *, int, struct fuse_flock *);
+ *     int (*utimens)(const char *, const struct fuse_timespec *, struct fuse3_file_info *);
+ *     int (*bmap)(const char *, size_t, uint64_t *);
+ *     int (*ioctl)(const char *, int, void *, struct fuse3_file_info *, unsigned int, void *);
+ *     int (*poll)(const char *, struct fuse3_file_info *, struct fuse3_pollhandle *, unsigned int *);
+ *     int (*write_buf)(const char *, struct fuse3_bufvec *, fuse_off_t, struct fuse3_file_info *);
+ *     int (*read_buf)(const char *, struct fuse3_bufvec **, size_t, fuse_off_t, struct fuse3_file_info *);
+ *     int (*flock)(const char *, struct fuse3_file_info *, int);
+ *     int (*fallocate)(const char *, int, fuse_off_t, fuse_off_t, struct fuse3_file_info *);
+ * }
  * }
  */
 public class fuse3_operations {
 
-    public static MemoryLayout $LAYOUT() {
-        return constants$12.const$1;
+    fuse3_operations() {
+        // Should not be called directly
     }
+
+    private static final GroupLayout $LAYOUT = MemoryLayout.structLayout(
+        fuse_h.C_POINTER.withName("getattr"),
+        fuse_h.C_POINTER.withName("readlink"),
+        fuse_h.C_POINTER.withName("mknod"),
+        fuse_h.C_POINTER.withName("mkdir"),
+        fuse_h.C_POINTER.withName("unlink"),
+        fuse_h.C_POINTER.withName("rmdir"),
+        fuse_h.C_POINTER.withName("symlink"),
+        fuse_h.C_POINTER.withName("rename"),
+        fuse_h.C_POINTER.withName("link"),
+        fuse_h.C_POINTER.withName("chmod"),
+        fuse_h.C_POINTER.withName("chown"),
+        fuse_h.C_POINTER.withName("truncate"),
+        fuse_h.C_POINTER.withName("open"),
+        fuse_h.C_POINTER.withName("read"),
+        fuse_h.C_POINTER.withName("write"),
+        fuse_h.C_POINTER.withName("statfs"),
+        fuse_h.C_POINTER.withName("flush"),
+        fuse_h.C_POINTER.withName("release"),
+        fuse_h.C_POINTER.withName("fsync"),
+        fuse_h.C_POINTER.withName("setxattr"),
+        fuse_h.C_POINTER.withName("getxattr"),
+        fuse_h.C_POINTER.withName("listxattr"),
+        fuse_h.C_POINTER.withName("removexattr"),
+        fuse_h.C_POINTER.withName("opendir"),
+        fuse_h.C_POINTER.withName("readdir"),
+        fuse_h.C_POINTER.withName("releasedir"),
+        fuse_h.C_POINTER.withName("fsyncdir"),
+        fuse_h.C_POINTER.withName("init"),
+        fuse_h.C_POINTER.withName("destroy"),
+        fuse_h.C_POINTER.withName("access"),
+        fuse_h.C_POINTER.withName("create"),
+        fuse_h.C_POINTER.withName("lock"),
+        fuse_h.C_POINTER.withName("utimens"),
+        fuse_h.C_POINTER.withName("bmap"),
+        fuse_h.C_POINTER.withName("ioctl"),
+        fuse_h.C_POINTER.withName("poll"),
+        fuse_h.C_POINTER.withName("write_buf"),
+        fuse_h.C_POINTER.withName("read_buf"),
+        fuse_h.C_POINTER.withName("flock"),
+        fuse_h.C_POINTER.withName("fallocate")
+    ).withName("fuse3_operations");
+
     /**
-     * {@snippet :
- * int (*getattr)(char*,struct fuse_stat*,struct fuse3_file_info*);
-     * }
+     * The layout of this struct
      */
-    public interface getattr {
-
-        int apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1, java.lang.foreign.MemorySegment _x2);
-        static MemorySegment allocate(getattr fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$12.const$3, fi, constants$12.const$2, scope);
-        }
-        static getattr ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1, java.lang.foreign.MemorySegment __x2) -> {
-                try {
-                    return (int)constants$12.const$4.invokeExact(symbol, __x0, __x1, __x2);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
-        }
+    public static final GroupLayout layout() {
+        return $LAYOUT;
     }
 
-    public static VarHandle getattr$VH() {
-        return constants$12.const$5;
-    }
     /**
-     * Getter for field:
-     * {@snippet :
-     * int (*getattr)(char*,struct fuse_stat*,struct fuse3_file_info*);
+     * {@snippet lang=c :
+     * int (*getattr)(const char *, struct fuse_stat *, struct fuse3_file_info *)
      * }
      */
-    public static MemorySegment getattr$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$12.const$5.get(seg);
+    public static class getattr {
+
+        getattr() {
+            // Should not be called directly
+        }
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, MemorySegment _x1, MemorySegment _x2);
+        }
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(getattr.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(getattr.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1, MemorySegment _x2) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
     }
+
+    private static final AddressLayout getattr$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("getattr"));
+
     /**
-     * Setter for field:
-     * {@snippet :
-     * int (*getattr)(char*,struct fuse_stat*,struct fuse3_file_info*);
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*getattr)(const char *, struct fuse_stat *, struct fuse3_file_info *)
      * }
      */
-    public static void getattr$set(MemorySegment seg, MemorySegment x) {
-        constants$12.const$5.set(seg, x);
-    }
-    public static MemorySegment getattr$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$12.const$5.get(seg.asSlice(index*sizeof()));
-    }
-    public static void getattr$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$12.const$5.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static getattr getattr(MemorySegment segment, Arena scope) {
-        return getattr.ofAddress(getattr$get(segment), scope);
+    public static final AddressLayout getattr$layout() {
+        return getattr$LAYOUT;
     }
+
+    private static final long getattr$OFFSET = 0;
+
     /**
-     * {@snippet :
- * int (*readlink)(char*,char*,unsigned long long);
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*getattr)(const char *, struct fuse_stat *, struct fuse3_file_info *)
      * }
      */
-    public interface readlink {
-
-        int apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1, long _x2);
-        static MemorySegment allocate(readlink fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$13.const$1, fi, constants$13.const$0, scope);
-        }
-        static readlink ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1, long __x2) -> {
-                try {
-                    return (int)constants$13.const$2.invokeExact(symbol, __x0, __x1, __x2);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
-        }
+    public static final long getattr$offset() {
+        return getattr$OFFSET;
     }
 
-    public static VarHandle readlink$VH() {
-        return constants$13.const$3;
-    }
     /**
      * Getter for field:
-     * {@snippet :
-     * int (*readlink)(char*,char*,unsigned long long);
+     * {@snippet lang=c :
+     * int (*getattr)(const char *, struct fuse_stat *, struct fuse3_file_info *)
      * }
      */
-    public static MemorySegment readlink$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$13.const$3.get(seg);
+    public static MemorySegment getattr(MemorySegment struct) {
+        return struct.get(getattr$LAYOUT, getattr$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int (*readlink)(char*,char*,unsigned long long);
+     * {@snippet lang=c :
+     * int (*getattr)(const char *, struct fuse_stat *, struct fuse3_file_info *)
      * }
      */
-    public static void readlink$set(MemorySegment seg, MemorySegment x) {
-        constants$13.const$3.set(seg, x);
-    }
-    public static MemorySegment readlink$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$13.const$3.get(seg.asSlice(index*sizeof()));
-    }
-    public static void readlink$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$13.const$3.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static readlink readlink(MemorySegment segment, Arena scope) {
-        return readlink.ofAddress(readlink$get(segment), scope);
+    public static void getattr(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(getattr$LAYOUT, getattr$OFFSET, fieldValue);
     }
+
     /**
-     * {@snippet :
- * int (*mknod)(char*,unsigned int,unsigned int);
+     * {@snippet lang=c :
+     * int (*readlink)(const char *, char *, size_t)
      * }
      */
-    public interface mknod {
+    public static class readlink {
 
-        int apply(java.lang.foreign.MemorySegment _x0, int _x1, int _x2);
-        static MemorySegment allocate(mknod fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$13.const$5, fi, constants$13.const$4, scope);
+        readlink() {
+            // Should not be called directly
         }
-        static mknod ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, int __x1, int __x2) -> {
-                try {
-                    return (int)constants$14.const$0.invokeExact(symbol, __x0, __x1, __x2);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, MemorySegment _x1, long _x2);
         }
-    }
 
-    public static VarHandle mknod$VH() {
-        return constants$14.const$1;
-    }
-    /**
-     * Getter for field:
-     * {@snippet :
-     * int (*mknod)(char*,unsigned int,unsigned int);
-     * }
-     */
-    public static MemorySegment mknod$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$14.const$1.get(seg);
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER,
+            fuse_h.C_LONG_LONG
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(readlink.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(readlink.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1, long _x2) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
     }
+
+    private static final AddressLayout readlink$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("readlink"));
+
     /**
-     * Setter for field:
-     * {@snippet :
-     * int (*mknod)(char*,unsigned int,unsigned int);
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*readlink)(const char *, char *, size_t)
      * }
      */
-    public static void mknod$set(MemorySegment seg, MemorySegment x) {
-        constants$14.const$1.set(seg, x);
-    }
-    public static MemorySegment mknod$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$14.const$1.get(seg.asSlice(index*sizeof()));
-    }
-    public static void mknod$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$14.const$1.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static mknod mknod(MemorySegment segment, Arena scope) {
-        return mknod.ofAddress(mknod$get(segment), scope);
+    public static final AddressLayout readlink$layout() {
+        return readlink$LAYOUT;
     }
+
+    private static final long readlink$OFFSET = 8;
+
     /**
-     * {@snippet :
- * int (*mkdir)(char*,unsigned int);
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*readlink)(const char *, char *, size_t)
      * }
      */
-    public interface mkdir {
-
-        int apply(java.lang.foreign.MemorySegment _x0, int _x1);
-        static MemorySegment allocate(mkdir fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$14.const$3, fi, constants$14.const$2, scope);
-        }
-        static mkdir ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, int __x1) -> {
-                try {
-                    return (int)constants$14.const$4.invokeExact(symbol, __x0, __x1);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
-        }
+    public static final long readlink$offset() {
+        return readlink$OFFSET;
     }
 
-    public static VarHandle mkdir$VH() {
-        return constants$14.const$5;
-    }
     /**
      * Getter for field:
-     * {@snippet :
-     * int (*mkdir)(char*,unsigned int);
+     * {@snippet lang=c :
+     * int (*readlink)(const char *, char *, size_t)
      * }
      */
-    public static MemorySegment mkdir$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$14.const$5.get(seg);
+    public static MemorySegment readlink(MemorySegment struct) {
+        return struct.get(readlink$LAYOUT, readlink$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int (*mkdir)(char*,unsigned int);
+     * {@snippet lang=c :
+     * int (*readlink)(const char *, char *, size_t)
      * }
      */
-    public static void mkdir$set(MemorySegment seg, MemorySegment x) {
-        constants$14.const$5.set(seg, x);
-    }
-    public static MemorySegment mkdir$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$14.const$5.get(seg.asSlice(index*sizeof()));
-    }
-    public static void mkdir$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$14.const$5.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static mkdir mkdir(MemorySegment segment, Arena scope) {
-        return mkdir.ofAddress(mkdir$get(segment), scope);
+    public static void readlink(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(readlink$LAYOUT, readlink$OFFSET, fieldValue);
     }
+
     /**
-     * {@snippet :
- * int (*unlink)(char*);
+     * {@snippet lang=c :
+     * int (*mknod)(const char *, fuse_mode_t, fuse_dev_t)
      * }
      */
-    public interface unlink {
+    public static class mknod {
 
-        int apply(java.lang.foreign.MemorySegment _x0);
-        static MemorySegment allocate(unlink fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$15.const$1, fi, constants$15.const$0, scope);
+        mknod() {
+            // Should not be called directly
         }
-        static unlink ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0) -> {
-                try {
-                    return (int)constants$15.const$2.invokeExact(symbol, __x0);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, int _x1, int _x2);
         }
-    }
 
-    public static VarHandle unlink$VH() {
-        return constants$15.const$3;
-    }
-    /**
-     * Getter for field:
-     * {@snippet :
-     * int (*unlink)(char*);
-     * }
-     */
-    public static MemorySegment unlink$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$15.const$3.get(seg);
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_INT,
+            fuse_h.C_INT
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(mknod.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(mknod.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, int _x1, int _x2) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
     }
+
+    private static final AddressLayout mknod$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("mknod"));
+
     /**
-     * Setter for field:
-     * {@snippet :
-     * int (*unlink)(char*);
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*mknod)(const char *, fuse_mode_t, fuse_dev_t)
      * }
      */
-    public static void unlink$set(MemorySegment seg, MemorySegment x) {
-        constants$15.const$3.set(seg, x);
-    }
-    public static MemorySegment unlink$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$15.const$3.get(seg.asSlice(index*sizeof()));
-    }
-    public static void unlink$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$15.const$3.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static unlink unlink(MemorySegment segment, Arena scope) {
-        return unlink.ofAddress(unlink$get(segment), scope);
+    public static final AddressLayout mknod$layout() {
+        return mknod$LAYOUT;
     }
+
+    private static final long mknod$OFFSET = 16;
+
     /**
-     * {@snippet :
- * int (*rmdir)(char*);
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*mknod)(const char *, fuse_mode_t, fuse_dev_t)
      * }
      */
-    public interface rmdir {
-
-        int apply(java.lang.foreign.MemorySegment _x0);
-        static MemorySegment allocate(rmdir fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$15.const$4, fi, constants$15.const$0, scope);
-        }
-        static rmdir ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0) -> {
-                try {
-                    return (int)constants$15.const$2.invokeExact(symbol, __x0);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
-        }
+    public static final long mknod$offset() {
+        return mknod$OFFSET;
     }
 
-    public static VarHandle rmdir$VH() {
-        return constants$15.const$5;
-    }
     /**
      * Getter for field:
-     * {@snippet :
-     * int (*rmdir)(char*);
+     * {@snippet lang=c :
+     * int (*mknod)(const char *, fuse_mode_t, fuse_dev_t)
      * }
      */
-    public static MemorySegment rmdir$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$15.const$5.get(seg);
+    public static MemorySegment mknod(MemorySegment struct) {
+        return struct.get(mknod$LAYOUT, mknod$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int (*rmdir)(char*);
+     * {@snippet lang=c :
+     * int (*mknod)(const char *, fuse_mode_t, fuse_dev_t)
      * }
      */
-    public static void rmdir$set(MemorySegment seg, MemorySegment x) {
-        constants$15.const$5.set(seg, x);
-    }
-    public static MemorySegment rmdir$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$15.const$5.get(seg.asSlice(index*sizeof()));
-    }
-    public static void rmdir$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$15.const$5.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static rmdir rmdir(MemorySegment segment, Arena scope) {
-        return rmdir.ofAddress(rmdir$get(segment), scope);
+    public static void mknod(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(mknod$LAYOUT, mknod$OFFSET, fieldValue);
     }
+
     /**
-     * {@snippet :
- * int (*symlink)(char*,char*);
+     * {@snippet lang=c :
+     * int (*mkdir)(const char *, fuse_mode_t)
      * }
      */
-    public interface symlink {
+    public static class mkdir {
 
-        int apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1);
-        static MemorySegment allocate(symlink fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$16.const$1, fi, constants$16.const$0, scope);
+        mkdir() {
+            // Should not be called directly
         }
-        static symlink ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1) -> {
-                try {
-                    return (int)constants$16.const$2.invokeExact(symbol, __x0, __x1);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, int _x1);
         }
-    }
 
-    public static VarHandle symlink$VH() {
-        return constants$16.const$3;
-    }
-    /**
-     * Getter for field:
-     * {@snippet :
-     * int (*symlink)(char*,char*);
-     * }
-     */
-    public static MemorySegment symlink$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$16.const$3.get(seg);
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_INT
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(mkdir.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(mkdir.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, int _x1) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
     }
+
+    private static final AddressLayout mkdir$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("mkdir"));
+
     /**
-     * Setter for field:
-     * {@snippet :
-     * int (*symlink)(char*,char*);
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*mkdir)(const char *, fuse_mode_t)
      * }
      */
-    public static void symlink$set(MemorySegment seg, MemorySegment x) {
-        constants$16.const$3.set(seg, x);
-    }
-    public static MemorySegment symlink$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$16.const$3.get(seg.asSlice(index*sizeof()));
-    }
-    public static void symlink$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$16.const$3.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static symlink symlink(MemorySegment segment, Arena scope) {
-        return symlink.ofAddress(symlink$get(segment), scope);
+    public static final AddressLayout mkdir$layout() {
+        return mkdir$LAYOUT;
     }
+
+    private static final long mkdir$OFFSET = 24;
+
     /**
-     * {@snippet :
- * int (*rename)(char*,char*,unsigned int);
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*mkdir)(const char *, fuse_mode_t)
      * }
      */
-    public interface rename {
-
-        int apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1, int _x2);
-        static MemorySegment allocate(rename fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$16.const$5, fi, constants$16.const$4, scope);
-        }
-        static rename ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1, int __x2) -> {
-                try {
-                    return (int)constants$17.const$0.invokeExact(symbol, __x0, __x1, __x2);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
-        }
+    public static final long mkdir$offset() {
+        return mkdir$OFFSET;
     }
 
-    public static VarHandle rename$VH() {
-        return constants$17.const$1;
-    }
     /**
      * Getter for field:
-     * {@snippet :
-     * int (*rename)(char*,char*,unsigned int);
+     * {@snippet lang=c :
+     * int (*mkdir)(const char *, fuse_mode_t)
      * }
      */
-    public static MemorySegment rename$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$17.const$1.get(seg);
+    public static MemorySegment mkdir(MemorySegment struct) {
+        return struct.get(mkdir$LAYOUT, mkdir$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int (*rename)(char*,char*,unsigned int);
+     * {@snippet lang=c :
+     * int (*mkdir)(const char *, fuse_mode_t)
      * }
      */
-    public static void rename$set(MemorySegment seg, MemorySegment x) {
-        constants$17.const$1.set(seg, x);
-    }
-    public static MemorySegment rename$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$17.const$1.get(seg.asSlice(index*sizeof()));
-    }
-    public static void rename$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$17.const$1.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static rename rename(MemorySegment segment, Arena scope) {
-        return rename.ofAddress(rename$get(segment), scope);
+    public static void mkdir(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(mkdir$LAYOUT, mkdir$OFFSET, fieldValue);
     }
+
     /**
-     * {@snippet :
- * int (*link)(char*,char*);
+     * {@snippet lang=c :
+     * int (*unlink)(const char *)
      * }
      */
-    public interface link {
+    public static class unlink {
 
-        int apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1);
-        static MemorySegment allocate(link fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$17.const$2, fi, constants$16.const$0, scope);
+        unlink() {
+            // Should not be called directly
         }
-        static link ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1) -> {
-                try {
-                    return (int)constants$16.const$2.invokeExact(symbol, __x0, __x1);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0);
         }
-    }
 
-    public static VarHandle link$VH() {
-        return constants$17.const$3;
-    }
-    /**
-     * Getter for field:
-     * {@snippet :
-     * int (*link)(char*,char*);
-     * }
-     */
-    public static MemorySegment link$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$17.const$3.get(seg);
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(unlink.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(unlink.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
     }
+
+    private static final AddressLayout unlink$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("unlink"));
+
     /**
-     * Setter for field:
-     * {@snippet :
-     * int (*link)(char*,char*);
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*unlink)(const char *)
      * }
      */
-    public static void link$set(MemorySegment seg, MemorySegment x) {
-        constants$17.const$3.set(seg, x);
-    }
-    public static MemorySegment link$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$17.const$3.get(seg.asSlice(index*sizeof()));
-    }
-    public static void link$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$17.const$3.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static link link(MemorySegment segment, Arena scope) {
-        return link.ofAddress(link$get(segment), scope);
+    public static final AddressLayout unlink$layout() {
+        return unlink$LAYOUT;
     }
+
+    private static final long unlink$OFFSET = 32;
+
     /**
-     * {@snippet :
- * int (*chmod)(char*,unsigned int,struct fuse3_file_info*);
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*unlink)(const char *)
      * }
      */
-    public interface chmod {
-
-        int apply(java.lang.foreign.MemorySegment _x0, int _x1, java.lang.foreign.MemorySegment _x2);
-        static MemorySegment allocate(chmod fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$17.const$5, fi, constants$17.const$4, scope);
-        }
-        static chmod ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, int __x1, java.lang.foreign.MemorySegment __x2) -> {
-                try {
-                    return (int)constants$18.const$0.invokeExact(symbol, __x0, __x1, __x2);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
-        }
+    public static final long unlink$offset() {
+        return unlink$OFFSET;
     }
 
-    public static VarHandle chmod$VH() {
-        return constants$18.const$1;
-    }
     /**
      * Getter for field:
-     * {@snippet :
-     * int (*chmod)(char*,unsigned int,struct fuse3_file_info*);
+     * {@snippet lang=c :
+     * int (*unlink)(const char *)
      * }
      */
-    public static MemorySegment chmod$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$18.const$1.get(seg);
+    public static MemorySegment unlink(MemorySegment struct) {
+        return struct.get(unlink$LAYOUT, unlink$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int (*chmod)(char*,unsigned int,struct fuse3_file_info*);
+     * {@snippet lang=c :
+     * int (*unlink)(const char *)
      * }
      */
-    public static void chmod$set(MemorySegment seg, MemorySegment x) {
-        constants$18.const$1.set(seg, x);
-    }
-    public static MemorySegment chmod$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$18.const$1.get(seg.asSlice(index*sizeof()));
-    }
-    public static void chmod$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$18.const$1.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static chmod chmod(MemorySegment segment, Arena scope) {
-        return chmod.ofAddress(chmod$get(segment), scope);
+    public static void unlink(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(unlink$LAYOUT, unlink$OFFSET, fieldValue);
     }
+
     /**
-     * {@snippet :
- * int (*chown)(char*,unsigned int,unsigned int,struct fuse3_file_info*);
+     * {@snippet lang=c :
+     * int (*rmdir)(const char *)
      * }
      */
-    public interface chown {
+    public static class rmdir {
 
-        int apply(java.lang.foreign.MemorySegment _x0, int _x1, int _x2, java.lang.foreign.MemorySegment _x3);
-        static MemorySegment allocate(chown fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$18.const$3, fi, constants$18.const$2, scope);
+        rmdir() {
+            // Should not be called directly
         }
-        static chown ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, int __x1, int __x2, java.lang.foreign.MemorySegment __x3) -> {
-                try {
-                    return (int)constants$18.const$4.invokeExact(symbol, __x0, __x1, __x2, __x3);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0);
         }
-    }
 
-    public static VarHandle chown$VH() {
-        return constants$18.const$5;
-    }
-    /**
-     * Getter for field:
-     * {@snippet :
-     * int (*chown)(char*,unsigned int,unsigned int,struct fuse3_file_info*);
-     * }
-     */
-    public static MemorySegment chown$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$18.const$5.get(seg);
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(rmdir.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(rmdir.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
     }
+
+    private static final AddressLayout rmdir$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("rmdir"));
+
     /**
-     * Setter for field:
-     * {@snippet :
-     * int (*chown)(char*,unsigned int,unsigned int,struct fuse3_file_info*);
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*rmdir)(const char *)
      * }
      */
-    public static void chown$set(MemorySegment seg, MemorySegment x) {
-        constants$18.const$5.set(seg, x);
-    }
-    public static MemorySegment chown$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$18.const$5.get(seg.asSlice(index*sizeof()));
-    }
-    public static void chown$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$18.const$5.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static chown chown(MemorySegment segment, Arena scope) {
-        return chown.ofAddress(chown$get(segment), scope);
+    public static final AddressLayout rmdir$layout() {
+        return rmdir$LAYOUT;
     }
+
+    private static final long rmdir$OFFSET = 40;
+
     /**
-     * {@snippet :
- * int (*truncate)(char*,long long,struct fuse3_file_info*);
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*rmdir)(const char *)
      * }
      */
-    public interface truncate {
-
-        int apply(java.lang.foreign.MemorySegment _x0, long _x1, java.lang.foreign.MemorySegment _x2);
-        static MemorySegment allocate(truncate fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$19.const$1, fi, constants$19.const$0, scope);
-        }
-        static truncate ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, long __x1, java.lang.foreign.MemorySegment __x2) -> {
-                try {
-                    return (int)constants$19.const$2.invokeExact(symbol, __x0, __x1, __x2);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
-        }
+    public static final long rmdir$offset() {
+        return rmdir$OFFSET;
     }
 
-    public static VarHandle truncate$VH() {
-        return constants$19.const$3;
-    }
     /**
      * Getter for field:
-     * {@snippet :
-     * int (*truncate)(char*,long long,struct fuse3_file_info*);
+     * {@snippet lang=c :
+     * int (*rmdir)(const char *)
      * }
      */
-    public static MemorySegment truncate$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$19.const$3.get(seg);
+    public static MemorySegment rmdir(MemorySegment struct) {
+        return struct.get(rmdir$LAYOUT, rmdir$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int (*truncate)(char*,long long,struct fuse3_file_info*);
+     * {@snippet lang=c :
+     * int (*rmdir)(const char *)
      * }
      */
-    public static void truncate$set(MemorySegment seg, MemorySegment x) {
-        constants$19.const$3.set(seg, x);
-    }
-    public static MemorySegment truncate$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$19.const$3.get(seg.asSlice(index*sizeof()));
-    }
-    public static void truncate$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$19.const$3.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static truncate truncate(MemorySegment segment, Arena scope) {
-        return truncate.ofAddress(truncate$get(segment), scope);
+    public static void rmdir(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(rmdir$LAYOUT, rmdir$OFFSET, fieldValue);
     }
+
     /**
-     * {@snippet :
- * int (*open)(char*,struct fuse3_file_info*);
+     * {@snippet lang=c :
+     * int (*symlink)(const char *, const char *)
      * }
      */
-    public interface open {
+    public static class symlink {
 
-        int apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1);
-        static MemorySegment allocate(open fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$19.const$4, fi, constants$16.const$0, scope);
+        symlink() {
+            // Should not be called directly
         }
-        static open ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1) -> {
-                try {
-                    return (int)constants$16.const$2.invokeExact(symbol, __x0, __x1);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, MemorySegment _x1);
         }
-    }
 
-    public static VarHandle open$VH() {
-        return constants$19.const$5;
-    }
-    /**
-     * Getter for field:
-     * {@snippet :
-     * int (*open)(char*,struct fuse3_file_info*);
-     * }
-     */
-    public static MemorySegment open$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$19.const$5.get(seg);
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(symlink.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(symlink.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
     }
+
+    private static final AddressLayout symlink$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("symlink"));
+
     /**
-     * Setter for field:
-     * {@snippet :
-     * int (*open)(char*,struct fuse3_file_info*);
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*symlink)(const char *, const char *)
      * }
      */
-    public static void open$set(MemorySegment seg, MemorySegment x) {
-        constants$19.const$5.set(seg, x);
-    }
-    public static MemorySegment open$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$19.const$5.get(seg.asSlice(index*sizeof()));
-    }
-    public static void open$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$19.const$5.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static open open(MemorySegment segment, Arena scope) {
-        return open.ofAddress(open$get(segment), scope);
+    public static final AddressLayout symlink$layout() {
+        return symlink$LAYOUT;
     }
+
+    private static final long symlink$OFFSET = 48;
+
     /**
-     * {@snippet :
- * int (*read)(char*,char*,unsigned long long,long long,struct fuse3_file_info*);
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*symlink)(const char *, const char *)
      * }
      */
-    public interface read {
-
-        int apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1, long _x2, long _x3, java.lang.foreign.MemorySegment _x4);
-        static MemorySegment allocate(read fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$20.const$1, fi, constants$20.const$0, scope);
-        }
-        static read ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1, long __x2, long __x3, java.lang.foreign.MemorySegment __x4) -> {
-                try {
-                    return (int)constants$20.const$2.invokeExact(symbol, __x0, __x1, __x2, __x3, __x4);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
-        }
+    public static final long symlink$offset() {
+        return symlink$OFFSET;
     }
 
-    public static VarHandle read$VH() {
-        return constants$20.const$3;
-    }
     /**
      * Getter for field:
-     * {@snippet :
-     * int (*read)(char*,char*,unsigned long long,long long,struct fuse3_file_info*);
+     * {@snippet lang=c :
+     * int (*symlink)(const char *, const char *)
      * }
      */
-    public static MemorySegment read$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$20.const$3.get(seg);
+    public static MemorySegment symlink(MemorySegment struct) {
+        return struct.get(symlink$LAYOUT, symlink$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int (*read)(char*,char*,unsigned long long,long long,struct fuse3_file_info*);
+     * {@snippet lang=c :
+     * int (*symlink)(const char *, const char *)
      * }
      */
-    public static void read$set(MemorySegment seg, MemorySegment x) {
-        constants$20.const$3.set(seg, x);
-    }
-    public static MemorySegment read$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$20.const$3.get(seg.asSlice(index*sizeof()));
-    }
-    public static void read$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$20.const$3.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static read read(MemorySegment segment, Arena scope) {
-        return read.ofAddress(read$get(segment), scope);
+    public static void symlink(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(symlink$LAYOUT, symlink$OFFSET, fieldValue);
     }
+
     /**
-     * {@snippet :
- * int (*write)(char*,char*,unsigned long long,long long,struct fuse3_file_info*);
+     * {@snippet lang=c :
+     * int (*rename)(const char *, const char *, unsigned int)
      * }
      */
-    public interface write {
+    public static class rename {
+
+        rename() {
+            // Should not be called directly
+        }
 
-        int apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1, long _x2, long _x3, java.lang.foreign.MemorySegment _x4);
-        static MemorySegment allocate(write fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$20.const$4, fi, constants$20.const$0, scope);
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, MemorySegment _x1, int _x2);
         }
-        static write ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1, long __x2, long __x3, java.lang.foreign.MemorySegment __x4) -> {
-                try {
-                    return (int)constants$20.const$2.invokeExact(symbol, __x0, __x1, __x2, __x3, __x4);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER,
+            fuse_h.C_INT
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
         }
-    }
 
-    public static VarHandle write$VH() {
-        return constants$20.const$5;
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(rename.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(rename.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1, int _x2) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
     }
+
+    private static final AddressLayout rename$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("rename"));
+
     /**
-     * Getter for field:
-     * {@snippet :
-     * int (*write)(char*,char*,unsigned long long,long long,struct fuse3_file_info*);
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*rename)(const char *, const char *, unsigned int)
      * }
      */
-    public static MemorySegment write$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$20.const$5.get(seg);
+    public static final AddressLayout rename$layout() {
+        return rename$LAYOUT;
     }
+
+    private static final long rename$OFFSET = 56;
+
     /**
-     * Setter for field:
-     * {@snippet :
-     * int (*write)(char*,char*,unsigned long long,long long,struct fuse3_file_info*);
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*rename)(const char *, const char *, unsigned int)
      * }
      */
-    public static void write$set(MemorySegment seg, MemorySegment x) {
-        constants$20.const$5.set(seg, x);
-    }
-    public static MemorySegment write$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$20.const$5.get(seg.asSlice(index*sizeof()));
-    }
-    public static void write$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$20.const$5.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static write write(MemorySegment segment, Arena scope) {
-        return write.ofAddress(write$get(segment), scope);
+    public static final long rename$offset() {
+        return rename$OFFSET;
     }
+
     /**
-     * {@snippet :
- * int (*statfs)(char*,struct fuse_statvfs*);
+     * Getter for field:
+     * {@snippet lang=c :
+     * int (*rename)(const char *, const char *, unsigned int)
      * }
      */
-    public interface statfs {
+    public static MemorySegment rename(MemorySegment struct) {
+        return struct.get(rename$LAYOUT, rename$OFFSET);
+    }
+
+    /**
+     * Setter for field:
+     * {@snippet lang=c :
+     * int (*rename)(const char *, const char *, unsigned int)
+     * }
+     */
+    public static void rename(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(rename$LAYOUT, rename$OFFSET, fieldValue);
+    }
+
+    /**
+     * {@snippet lang=c :
+     * int (*link)(const char *, const char *)
+     * }
+     */
+    public static class link {
+
+        link() {
+            // Should not be called directly
+        }
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, MemorySegment _x1);
+        }
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(link.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(link.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
+    }
+
+    private static final AddressLayout link$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("link"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*link)(const char *, const char *)
+     * }
+     */
+    public static final AddressLayout link$layout() {
+        return link$LAYOUT;
+    }
+
+    private static final long link$OFFSET = 64;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*link)(const char *, const char *)
+     * }
+     */
+    public static final long link$offset() {
+        return link$OFFSET;
+    }
+
+    /**
+     * Getter for field:
+     * {@snippet lang=c :
+     * int (*link)(const char *, const char *)
+     * }
+     */
+    public static MemorySegment link(MemorySegment struct) {
+        return struct.get(link$LAYOUT, link$OFFSET);
+    }
+
+    /**
+     * Setter for field:
+     * {@snippet lang=c :
+     * int (*link)(const char *, const char *)
+     * }
+     */
+    public static void link(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(link$LAYOUT, link$OFFSET, fieldValue);
+    }
+
+    /**
+     * {@snippet lang=c :
+     * int (*chmod)(const char *, fuse_mode_t, struct fuse3_file_info *)
+     * }
+     */
+    public static class chmod {
+
+        chmod() {
+            // Should not be called directly
+        }
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, int _x1, MemorySegment _x2);
+        }
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_INT,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(chmod.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(chmod.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, int _x1, MemorySegment _x2) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
+    }
+
+    private static final AddressLayout chmod$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("chmod"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*chmod)(const char *, fuse_mode_t, struct fuse3_file_info *)
+     * }
+     */
+    public static final AddressLayout chmod$layout() {
+        return chmod$LAYOUT;
+    }
+
+    private static final long chmod$OFFSET = 72;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*chmod)(const char *, fuse_mode_t, struct fuse3_file_info *)
+     * }
+     */
+    public static final long chmod$offset() {
+        return chmod$OFFSET;
+    }
+
+    /**
+     * Getter for field:
+     * {@snippet lang=c :
+     * int (*chmod)(const char *, fuse_mode_t, struct fuse3_file_info *)
+     * }
+     */
+    public static MemorySegment chmod(MemorySegment struct) {
+        return struct.get(chmod$LAYOUT, chmod$OFFSET);
+    }
+
+    /**
+     * Setter for field:
+     * {@snippet lang=c :
+     * int (*chmod)(const char *, fuse_mode_t, struct fuse3_file_info *)
+     * }
+     */
+    public static void chmod(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(chmod$LAYOUT, chmod$OFFSET, fieldValue);
+    }
+
+    /**
+     * {@snippet lang=c :
+     * int (*chown)(const char *, fuse_uid_t, fuse_gid_t, struct fuse3_file_info *)
+     * }
+     */
+    public static class chown {
+
+        chown() {
+            // Should not be called directly
+        }
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, int _x1, int _x2, MemorySegment _x3);
+        }
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_INT,
+            fuse_h.C_INT,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(chown.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(chown.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, int _x1, int _x2, MemorySegment _x3) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2, _x3);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
+    }
+
+    private static final AddressLayout chown$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("chown"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*chown)(const char *, fuse_uid_t, fuse_gid_t, struct fuse3_file_info *)
+     * }
+     */
+    public static final AddressLayout chown$layout() {
+        return chown$LAYOUT;
+    }
+
+    private static final long chown$OFFSET = 80;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*chown)(const char *, fuse_uid_t, fuse_gid_t, struct fuse3_file_info *)
+     * }
+     */
+    public static final long chown$offset() {
+        return chown$OFFSET;
+    }
+
+    /**
+     * Getter for field:
+     * {@snippet lang=c :
+     * int (*chown)(const char *, fuse_uid_t, fuse_gid_t, struct fuse3_file_info *)
+     * }
+     */
+    public static MemorySegment chown(MemorySegment struct) {
+        return struct.get(chown$LAYOUT, chown$OFFSET);
+    }
+
+    /**
+     * Setter for field:
+     * {@snippet lang=c :
+     * int (*chown)(const char *, fuse_uid_t, fuse_gid_t, struct fuse3_file_info *)
+     * }
+     */
+    public static void chown(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(chown$LAYOUT, chown$OFFSET, fieldValue);
+    }
+
+    /**
+     * {@snippet lang=c :
+     * int (*truncate)(const char *, fuse_off_t, struct fuse3_file_info *)
+     * }
+     */
+    public static class truncate {
+
+        truncate() {
+            // Should not be called directly
+        }
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, long _x1, MemorySegment _x2);
+        }
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_LONG_LONG,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(truncate.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(truncate.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, long _x1, MemorySegment _x2) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
+    }
+
+    private static final AddressLayout truncate$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("truncate"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*truncate)(const char *, fuse_off_t, struct fuse3_file_info *)
+     * }
+     */
+    public static final AddressLayout truncate$layout() {
+        return truncate$LAYOUT;
+    }
+
+    private static final long truncate$OFFSET = 88;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*truncate)(const char *, fuse_off_t, struct fuse3_file_info *)
+     * }
+     */
+    public static final long truncate$offset() {
+        return truncate$OFFSET;
+    }
+
+    /**
+     * Getter for field:
+     * {@snippet lang=c :
+     * int (*truncate)(const char *, fuse_off_t, struct fuse3_file_info *)
+     * }
+     */
+    public static MemorySegment truncate(MemorySegment struct) {
+        return struct.get(truncate$LAYOUT, truncate$OFFSET);
+    }
+
+    /**
+     * Setter for field:
+     * {@snippet lang=c :
+     * int (*truncate)(const char *, fuse_off_t, struct fuse3_file_info *)
+     * }
+     */
+    public static void truncate(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(truncate$LAYOUT, truncate$OFFSET, fieldValue);
+    }
+
+    /**
+     * {@snippet lang=c :
+     * int (*open)(const char *, struct fuse3_file_info *)
+     * }
+     */
+    public static class open {
+
+        open() {
+            // Should not be called directly
+        }
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, MemorySegment _x1);
+        }
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(open.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(open.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
+    }
+
+    private static final AddressLayout open$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("open"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*open)(const char *, struct fuse3_file_info *)
+     * }
+     */
+    public static final AddressLayout open$layout() {
+        return open$LAYOUT;
+    }
+
+    private static final long open$OFFSET = 96;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*open)(const char *, struct fuse3_file_info *)
+     * }
+     */
+    public static final long open$offset() {
+        return open$OFFSET;
+    }
+
+    /**
+     * Getter for field:
+     * {@snippet lang=c :
+     * int (*open)(const char *, struct fuse3_file_info *)
+     * }
+     */
+    public static MemorySegment open(MemorySegment struct) {
+        return struct.get(open$LAYOUT, open$OFFSET);
+    }
+
+    /**
+     * Setter for field:
+     * {@snippet lang=c :
+     * int (*open)(const char *, struct fuse3_file_info *)
+     * }
+     */
+    public static void open(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(open$LAYOUT, open$OFFSET, fieldValue);
+    }
+
+    /**
+     * {@snippet lang=c :
+     * int (*read)(const char *, char *, size_t, fuse_off_t, struct fuse3_file_info *)
+     * }
+     */
+    public static class read {
+
+        read() {
+            // Should not be called directly
+        }
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, MemorySegment _x1, long _x2, long _x3, MemorySegment _x4);
+        }
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER,
+            fuse_h.C_LONG_LONG,
+            fuse_h.C_LONG_LONG,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(read.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(read.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1, long _x2, long _x3, MemorySegment _x4) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2, _x3, _x4);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
+    }
+
+    private static final AddressLayout read$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("read"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*read)(const char *, char *, size_t, fuse_off_t, struct fuse3_file_info *)
+     * }
+     */
+    public static final AddressLayout read$layout() {
+        return read$LAYOUT;
+    }
+
+    private static final long read$OFFSET = 104;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*read)(const char *, char *, size_t, fuse_off_t, struct fuse3_file_info *)
+     * }
+     */
+    public static final long read$offset() {
+        return read$OFFSET;
+    }
+
+    /**
+     * Getter for field:
+     * {@snippet lang=c :
+     * int (*read)(const char *, char *, size_t, fuse_off_t, struct fuse3_file_info *)
+     * }
+     */
+    public static MemorySegment read(MemorySegment struct) {
+        return struct.get(read$LAYOUT, read$OFFSET);
+    }
+
+    /**
+     * Setter for field:
+     * {@snippet lang=c :
+     * int (*read)(const char *, char *, size_t, fuse_off_t, struct fuse3_file_info *)
+     * }
+     */
+    public static void read(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(read$LAYOUT, read$OFFSET, fieldValue);
+    }
+
+    /**
+     * {@snippet lang=c :
+     * int (*write)(const char *, const char *, size_t, fuse_off_t, struct fuse3_file_info *)
+     * }
+     */
+    public static class write {
+
+        write() {
+            // Should not be called directly
+        }
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, MemorySegment _x1, long _x2, long _x3, MemorySegment _x4);
+        }
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER,
+            fuse_h.C_LONG_LONG,
+            fuse_h.C_LONG_LONG,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(write.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(write.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1, long _x2, long _x3, MemorySegment _x4) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2, _x3, _x4);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
+    }
+
+    private static final AddressLayout write$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("write"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*write)(const char *, const char *, size_t, fuse_off_t, struct fuse3_file_info *)
+     * }
+     */
+    public static final AddressLayout write$layout() {
+        return write$LAYOUT;
+    }
+
+    private static final long write$OFFSET = 112;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*write)(const char *, const char *, size_t, fuse_off_t, struct fuse3_file_info *)
+     * }
+     */
+    public static final long write$offset() {
+        return write$OFFSET;
+    }
+
+    /**
+     * Getter for field:
+     * {@snippet lang=c :
+     * int (*write)(const char *, const char *, size_t, fuse_off_t, struct fuse3_file_info *)
+     * }
+     */
+    public static MemorySegment write(MemorySegment struct) {
+        return struct.get(write$LAYOUT, write$OFFSET);
+    }
+
+    /**
+     * Setter for field:
+     * {@snippet lang=c :
+     * int (*write)(const char *, const char *, size_t, fuse_off_t, struct fuse3_file_info *)
+     * }
+     */
+    public static void write(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(write$LAYOUT, write$OFFSET, fieldValue);
+    }
+
+    /**
+     * {@snippet lang=c :
+     * int (*statfs)(const char *, struct fuse_statvfs *)
+     * }
+     */
+    public static class statfs {
+
+        statfs() {
+            // Should not be called directly
+        }
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, MemorySegment _x1);
+        }
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(statfs.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(statfs.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
+    }
+
+    private static final AddressLayout statfs$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("statfs"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*statfs)(const char *, struct fuse_statvfs *)
+     * }
+     */
+    public static final AddressLayout statfs$layout() {
+        return statfs$LAYOUT;
+    }
+
+    private static final long statfs$OFFSET = 120;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*statfs)(const char *, struct fuse_statvfs *)
+     * }
+     */
+    public static final long statfs$offset() {
+        return statfs$OFFSET;
+    }
+
+    /**
+     * Getter for field:
+     * {@snippet lang=c :
+     * int (*statfs)(const char *, struct fuse_statvfs *)
+     * }
+     */
+    public static MemorySegment statfs(MemorySegment struct) {
+        return struct.get(statfs$LAYOUT, statfs$OFFSET);
+    }
+
+    /**
+     * Setter for field:
+     * {@snippet lang=c :
+     * int (*statfs)(const char *, struct fuse_statvfs *)
+     * }
+     */
+    public static void statfs(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(statfs$LAYOUT, statfs$OFFSET, fieldValue);
+    }
+
+    /**
+     * {@snippet lang=c :
+     * int (*flush)(const char *, struct fuse3_file_info *)
+     * }
+     */
+    public static class flush {
+
+        flush() {
+            // Should not be called directly
+        }
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, MemorySegment _x1);
+        }
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(flush.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(flush.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
+    }
+
+    private static final AddressLayout flush$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("flush"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*flush)(const char *, struct fuse3_file_info *)
+     * }
+     */
+    public static final AddressLayout flush$layout() {
+        return flush$LAYOUT;
+    }
+
+    private static final long flush$OFFSET = 128;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*flush)(const char *, struct fuse3_file_info *)
+     * }
+     */
+    public static final long flush$offset() {
+        return flush$OFFSET;
+    }
+
+    /**
+     * Getter for field:
+     * {@snippet lang=c :
+     * int (*flush)(const char *, struct fuse3_file_info *)
+     * }
+     */
+    public static MemorySegment flush(MemorySegment struct) {
+        return struct.get(flush$LAYOUT, flush$OFFSET);
+    }
+
+    /**
+     * Setter for field:
+     * {@snippet lang=c :
+     * int (*flush)(const char *, struct fuse3_file_info *)
+     * }
+     */
+    public static void flush(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(flush$LAYOUT, flush$OFFSET, fieldValue);
+    }
+
+    /**
+     * {@snippet lang=c :
+     * int (*release)(const char *, struct fuse3_file_info *)
+     * }
+     */
+    public static class release {
+
+        release() {
+            // Should not be called directly
+        }
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, MemorySegment _x1);
+        }
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(release.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(release.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
+    }
+
+    private static final AddressLayout release$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("release"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*release)(const char *, struct fuse3_file_info *)
+     * }
+     */
+    public static final AddressLayout release$layout() {
+        return release$LAYOUT;
+    }
+
+    private static final long release$OFFSET = 136;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*release)(const char *, struct fuse3_file_info *)
+     * }
+     */
+    public static final long release$offset() {
+        return release$OFFSET;
+    }
+
+    /**
+     * Getter for field:
+     * {@snippet lang=c :
+     * int (*release)(const char *, struct fuse3_file_info *)
+     * }
+     */
+    public static MemorySegment release(MemorySegment struct) {
+        return struct.get(release$LAYOUT, release$OFFSET);
+    }
+
+    /**
+     * Setter for field:
+     * {@snippet lang=c :
+     * int (*release)(const char *, struct fuse3_file_info *)
+     * }
+     */
+    public static void release(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(release$LAYOUT, release$OFFSET, fieldValue);
+    }
+
+    /**
+     * {@snippet lang=c :
+     * int (*fsync)(const char *, int, struct fuse3_file_info *)
+     * }
+     */
+    public static class fsync {
+
+        fsync() {
+            // Should not be called directly
+        }
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, int _x1, MemorySegment _x2);
+        }
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_INT,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(fsync.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(fsync.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, int _x1, MemorySegment _x2) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
+    }
+
+    private static final AddressLayout fsync$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("fsync"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*fsync)(const char *, int, struct fuse3_file_info *)
+     * }
+     */
+    public static final AddressLayout fsync$layout() {
+        return fsync$LAYOUT;
+    }
+
+    private static final long fsync$OFFSET = 144;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*fsync)(const char *, int, struct fuse3_file_info *)
+     * }
+     */
+    public static final long fsync$offset() {
+        return fsync$OFFSET;
+    }
+
+    /**
+     * Getter for field:
+     * {@snippet lang=c :
+     * int (*fsync)(const char *, int, struct fuse3_file_info *)
+     * }
+     */
+    public static MemorySegment fsync(MemorySegment struct) {
+        return struct.get(fsync$LAYOUT, fsync$OFFSET);
+    }
+
+    /**
+     * Setter for field:
+     * {@snippet lang=c :
+     * int (*fsync)(const char *, int, struct fuse3_file_info *)
+     * }
+     */
+    public static void fsync(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(fsync$LAYOUT, fsync$OFFSET, fieldValue);
+    }
+
+    /**
+     * {@snippet lang=c :
+     * int (*setxattr)(const char *, const char *, const char *, size_t, int)
+     * }
+     */
+    public static class setxattr {
+
+        setxattr() {
+            // Should not be called directly
+        }
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, MemorySegment _x1, MemorySegment _x2, long _x3, int _x4);
+        }
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER,
+            fuse_h.C_LONG_LONG,
+            fuse_h.C_INT
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(setxattr.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(setxattr.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1, MemorySegment _x2, long _x3, int _x4) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2, _x3, _x4);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
+    }
+
+    private static final AddressLayout setxattr$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("setxattr"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*setxattr)(const char *, const char *, const char *, size_t, int)
+     * }
+     */
+    public static final AddressLayout setxattr$layout() {
+        return setxattr$LAYOUT;
+    }
+
+    private static final long setxattr$OFFSET = 152;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*setxattr)(const char *, const char *, const char *, size_t, int)
+     * }
+     */
+    public static final long setxattr$offset() {
+        return setxattr$OFFSET;
+    }
+
+    /**
+     * Getter for field:
+     * {@snippet lang=c :
+     * int (*setxattr)(const char *, const char *, const char *, size_t, int)
+     * }
+     */
+    public static MemorySegment setxattr(MemorySegment struct) {
+        return struct.get(setxattr$LAYOUT, setxattr$OFFSET);
+    }
+
+    /**
+     * Setter for field:
+     * {@snippet lang=c :
+     * int (*setxattr)(const char *, const char *, const char *, size_t, int)
+     * }
+     */
+    public static void setxattr(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(setxattr$LAYOUT, setxattr$OFFSET, fieldValue);
+    }
+
+    /**
+     * {@snippet lang=c :
+     * int (*getxattr)(const char *, const char *, char *, size_t)
+     * }
+     */
+    public static class getxattr {
+
+        getxattr() {
+            // Should not be called directly
+        }
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, MemorySegment _x1, MemorySegment _x2, long _x3);
+        }
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER,
+            fuse_h.C_LONG_LONG
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(getxattr.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(getxattr.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1, MemorySegment _x2, long _x3) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2, _x3);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
+    }
+
+    private static final AddressLayout getxattr$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("getxattr"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*getxattr)(const char *, const char *, char *, size_t)
+     * }
+     */
+    public static final AddressLayout getxattr$layout() {
+        return getxattr$LAYOUT;
+    }
+
+    private static final long getxattr$OFFSET = 160;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*getxattr)(const char *, const char *, char *, size_t)
+     * }
+     */
+    public static final long getxattr$offset() {
+        return getxattr$OFFSET;
+    }
+
+    /**
+     * Getter for field:
+     * {@snippet lang=c :
+     * int (*getxattr)(const char *, const char *, char *, size_t)
+     * }
+     */
+    public static MemorySegment getxattr(MemorySegment struct) {
+        return struct.get(getxattr$LAYOUT, getxattr$OFFSET);
+    }
+
+    /**
+     * Setter for field:
+     * {@snippet lang=c :
+     * int (*getxattr)(const char *, const char *, char *, size_t)
+     * }
+     */
+    public static void getxattr(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(getxattr$LAYOUT, getxattr$OFFSET, fieldValue);
+    }
+
+    /**
+     * {@snippet lang=c :
+     * int (*listxattr)(const char *, char *, size_t)
+     * }
+     */
+    public static class listxattr {
+
+        listxattr() {
+            // Should not be called directly
+        }
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, MemorySegment _x1, long _x2);
+        }
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER,
+            fuse_h.C_LONG_LONG
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(listxattr.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(listxattr.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1, long _x2) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
+    }
+
+    private static final AddressLayout listxattr$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("listxattr"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*listxattr)(const char *, char *, size_t)
+     * }
+     */
+    public static final AddressLayout listxattr$layout() {
+        return listxattr$LAYOUT;
+    }
+
+    private static final long listxattr$OFFSET = 168;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*listxattr)(const char *, char *, size_t)
+     * }
+     */
+    public static final long listxattr$offset() {
+        return listxattr$OFFSET;
+    }
+
+    /**
+     * Getter for field:
+     * {@snippet lang=c :
+     * int (*listxattr)(const char *, char *, size_t)
+     * }
+     */
+    public static MemorySegment listxattr(MemorySegment struct) {
+        return struct.get(listxattr$LAYOUT, listxattr$OFFSET);
+    }
+
+    /**
+     * Setter for field:
+     * {@snippet lang=c :
+     * int (*listxattr)(const char *, char *, size_t)
+     * }
+     */
+    public static void listxattr(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(listxattr$LAYOUT, listxattr$OFFSET, fieldValue);
+    }
+
+    /**
+     * {@snippet lang=c :
+     * int (*removexattr)(const char *, const char *)
+     * }
+     */
+    public static class removexattr {
+
+        removexattr() {
+            // Should not be called directly
+        }
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, MemorySegment _x1);
+        }
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(removexattr.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(removexattr.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
+    }
+
+    private static final AddressLayout removexattr$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("removexattr"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*removexattr)(const char *, const char *)
+     * }
+     */
+    public static final AddressLayout removexattr$layout() {
+        return removexattr$LAYOUT;
+    }
+
+    private static final long removexattr$OFFSET = 176;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*removexattr)(const char *, const char *)
+     * }
+     */
+    public static final long removexattr$offset() {
+        return removexattr$OFFSET;
+    }
+
+    /**
+     * Getter for field:
+     * {@snippet lang=c :
+     * int (*removexattr)(const char *, const char *)
+     * }
+     */
+    public static MemorySegment removexattr(MemorySegment struct) {
+        return struct.get(removexattr$LAYOUT, removexattr$OFFSET);
+    }
+
+    /**
+     * Setter for field:
+     * {@snippet lang=c :
+     * int (*removexattr)(const char *, const char *)
+     * }
+     */
+    public static void removexattr(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(removexattr$LAYOUT, removexattr$OFFSET, fieldValue);
+    }
 
-        int apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1);
-        static MemorySegment allocate(statfs fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$21.const$0, fi, constants$16.const$0, scope);
+    /**
+     * {@snippet lang=c :
+     * int (*opendir)(const char *, struct fuse3_file_info *)
+     * }
+     */
+    public static class opendir {
+
+        opendir() {
+            // Should not be called directly
+        }
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, MemorySegment _x1);
+        }
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(opendir.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(opendir.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
         }
-        static statfs ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1) -> {
-                try {
-                    return (int)constants$16.const$2.invokeExact(symbol, __x0, __x1);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
         }
     }
 
-    public static VarHandle statfs$VH() {
-        return constants$21.const$1;
+    private static final AddressLayout opendir$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("opendir"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*opendir)(const char *, struct fuse3_file_info *)
+     * }
+     */
+    public static final AddressLayout opendir$layout() {
+        return opendir$LAYOUT;
+    }
+
+    private static final long opendir$OFFSET = 184;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*opendir)(const char *, struct fuse3_file_info *)
+     * }
+     */
+    public static final long opendir$offset() {
+        return opendir$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int (*statfs)(char*,struct fuse_statvfs*);
+     * {@snippet lang=c :
+     * int (*opendir)(const char *, struct fuse3_file_info *)
      * }
      */
-    public static MemorySegment statfs$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$21.const$1.get(seg);
+    public static MemorySegment opendir(MemorySegment struct) {
+        return struct.get(opendir$LAYOUT, opendir$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int (*statfs)(char*,struct fuse_statvfs*);
+     * {@snippet lang=c :
+     * int (*opendir)(const char *, struct fuse3_file_info *)
      * }
      */
-    public static void statfs$set(MemorySegment seg, MemorySegment x) {
-        constants$21.const$1.set(seg, x);
-    }
-    public static MemorySegment statfs$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$21.const$1.get(seg.asSlice(index*sizeof()));
-    }
-    public static void statfs$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$21.const$1.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static statfs statfs(MemorySegment segment, Arena scope) {
-        return statfs.ofAddress(statfs$get(segment), scope);
+    public static void opendir(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(opendir$LAYOUT, opendir$OFFSET, fieldValue);
     }
+
     /**
-     * {@snippet :
- * int (*flush)(char*,struct fuse3_file_info*);
+     * {@snippet lang=c :
+     * int (*readdir)(const char *, void *, fuse3_fill_dir_t, fuse_off_t, struct fuse3_file_info *, enum fuse3_readdir_flags)
      * }
      */
-    public interface flush {
+    public static class readdir {
+
+        readdir() {
+            // Should not be called directly
+        }
 
-        int apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1);
-        static MemorySegment allocate(flush fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$21.const$2, fi, constants$16.const$0, scope);
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, MemorySegment _x1, MemorySegment _x2, long _x3, MemorySegment _x4, int _x5);
         }
-        static flush ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1) -> {
-                try {
-                    return (int)constants$16.const$2.invokeExact(symbol, __x0, __x1);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER,
+            fuse_h.C_LONG_LONG,
+            fuse_h.C_POINTER,
+            fuse_h.C_INT
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(readdir.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(readdir.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1, MemorySegment _x2, long _x3, MemorySegment _x4, int _x5) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2, _x3, _x4, _x5);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
         }
     }
 
-    public static VarHandle flush$VH() {
-        return constants$21.const$3;
+    private static final AddressLayout readdir$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("readdir"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*readdir)(const char *, void *, fuse3_fill_dir_t, fuse_off_t, struct fuse3_file_info *, enum fuse3_readdir_flags)
+     * }
+     */
+    public static final AddressLayout readdir$layout() {
+        return readdir$LAYOUT;
+    }
+
+    private static final long readdir$OFFSET = 192;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*readdir)(const char *, void *, fuse3_fill_dir_t, fuse_off_t, struct fuse3_file_info *, enum fuse3_readdir_flags)
+     * }
+     */
+    public static final long readdir$offset() {
+        return readdir$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int (*flush)(char*,struct fuse3_file_info*);
+     * {@snippet lang=c :
+     * int (*readdir)(const char *, void *, fuse3_fill_dir_t, fuse_off_t, struct fuse3_file_info *, enum fuse3_readdir_flags)
      * }
      */
-    public static MemorySegment flush$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$21.const$3.get(seg);
+    public static MemorySegment readdir(MemorySegment struct) {
+        return struct.get(readdir$LAYOUT, readdir$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int (*flush)(char*,struct fuse3_file_info*);
+     * {@snippet lang=c :
+     * int (*readdir)(const char *, void *, fuse3_fill_dir_t, fuse_off_t, struct fuse3_file_info *, enum fuse3_readdir_flags)
      * }
      */
-    public static void flush$set(MemorySegment seg, MemorySegment x) {
-        constants$21.const$3.set(seg, x);
-    }
-    public static MemorySegment flush$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$21.const$3.get(seg.asSlice(index*sizeof()));
-    }
-    public static void flush$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$21.const$3.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static flush flush(MemorySegment segment, Arena scope) {
-        return flush.ofAddress(flush$get(segment), scope);
+    public static void readdir(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(readdir$LAYOUT, readdir$OFFSET, fieldValue);
     }
+
     /**
-     * {@snippet :
- * int (*release)(char*,struct fuse3_file_info*);
+     * {@snippet lang=c :
+     * int (*releasedir)(const char *, struct fuse3_file_info *)
      * }
      */
-    public interface release {
+    public static class releasedir {
+
+        releasedir() {
+            // Should not be called directly
+        }
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, MemorySegment _x1);
+        }
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(releasedir.Function.class, "apply", $DESC);
 
-        int apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1);
-        static MemorySegment allocate(release fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$21.const$4, fi, constants$16.const$0, scope);
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(releasedir.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
         }
-        static release ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1) -> {
-                try {
-                    return (int)constants$16.const$2.invokeExact(symbol, __x0, __x1);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
         }
     }
 
-    public static VarHandle release$VH() {
-        return constants$21.const$5;
+    private static final AddressLayout releasedir$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("releasedir"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*releasedir)(const char *, struct fuse3_file_info *)
+     * }
+     */
+    public static final AddressLayout releasedir$layout() {
+        return releasedir$LAYOUT;
+    }
+
+    private static final long releasedir$OFFSET = 200;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*releasedir)(const char *, struct fuse3_file_info *)
+     * }
+     */
+    public static final long releasedir$offset() {
+        return releasedir$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int (*release)(char*,struct fuse3_file_info*);
+     * {@snippet lang=c :
+     * int (*releasedir)(const char *, struct fuse3_file_info *)
      * }
      */
-    public static MemorySegment release$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$21.const$5.get(seg);
+    public static MemorySegment releasedir(MemorySegment struct) {
+        return struct.get(releasedir$LAYOUT, releasedir$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int (*release)(char*,struct fuse3_file_info*);
+     * {@snippet lang=c :
+     * int (*releasedir)(const char *, struct fuse3_file_info *)
      * }
      */
-    public static void release$set(MemorySegment seg, MemorySegment x) {
-        constants$21.const$5.set(seg, x);
-    }
-    public static MemorySegment release$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$21.const$5.get(seg.asSlice(index*sizeof()));
-    }
-    public static void release$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$21.const$5.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static release release(MemorySegment segment, Arena scope) {
-        return release.ofAddress(release$get(segment), scope);
+    public static void releasedir(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(releasedir$LAYOUT, releasedir$OFFSET, fieldValue);
     }
+
     /**
-     * {@snippet :
- * int (*fsync)(char*,int,struct fuse3_file_info*);
+     * {@snippet lang=c :
+     * int (*fsyncdir)(const char *, int, struct fuse3_file_info *)
      * }
      */
-    public interface fsync {
+    public static class fsyncdir {
+
+        fsyncdir() {
+            // Should not be called directly
+        }
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, int _x1, MemorySegment _x2);
+        }
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_INT,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(fsyncdir.Function.class, "apply", $DESC);
 
-        int apply(java.lang.foreign.MemorySegment _x0, int _x1, java.lang.foreign.MemorySegment _x2);
-        static MemorySegment allocate(fsync fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$22.const$0, fi, constants$17.const$4, scope);
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(fsyncdir.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
         }
-        static fsync ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, int __x1, java.lang.foreign.MemorySegment __x2) -> {
-                try {
-                    return (int)constants$18.const$0.invokeExact(symbol, __x0, __x1, __x2);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, int _x1, MemorySegment _x2) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
         }
     }
 
-    public static VarHandle fsync$VH() {
-        return constants$22.const$1;
+    private static final AddressLayout fsyncdir$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("fsyncdir"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*fsyncdir)(const char *, int, struct fuse3_file_info *)
+     * }
+     */
+    public static final AddressLayout fsyncdir$layout() {
+        return fsyncdir$LAYOUT;
+    }
+
+    private static final long fsyncdir$OFFSET = 208;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*fsyncdir)(const char *, int, struct fuse3_file_info *)
+     * }
+     */
+    public static final long fsyncdir$offset() {
+        return fsyncdir$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int (*fsync)(char*,int,struct fuse3_file_info*);
+     * {@snippet lang=c :
+     * int (*fsyncdir)(const char *, int, struct fuse3_file_info *)
      * }
      */
-    public static MemorySegment fsync$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$22.const$1.get(seg);
+    public static MemorySegment fsyncdir(MemorySegment struct) {
+        return struct.get(fsyncdir$LAYOUT, fsyncdir$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int (*fsync)(char*,int,struct fuse3_file_info*);
+     * {@snippet lang=c :
+     * int (*fsyncdir)(const char *, int, struct fuse3_file_info *)
      * }
      */
-    public static void fsync$set(MemorySegment seg, MemorySegment x) {
-        constants$22.const$1.set(seg, x);
-    }
-    public static MemorySegment fsync$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$22.const$1.get(seg.asSlice(index*sizeof()));
-    }
-    public static void fsync$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$22.const$1.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static fsync fsync(MemorySegment segment, Arena scope) {
-        return fsync.ofAddress(fsync$get(segment), scope);
+    public static void fsyncdir(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(fsyncdir$LAYOUT, fsyncdir$OFFSET, fieldValue);
     }
+
     /**
-     * {@snippet :
- * int (*setxattr)(char*,char*,char*,unsigned long long,int);
+     * {@snippet lang=c :
+     * void *(*init)(struct fuse3_conn_info *, struct fuse3_config *)
      * }
      */
-    public interface setxattr {
+    public static class init {
+
+        init() {
+            // Should not be called directly
+        }
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            MemorySegment apply(MemorySegment _x0, MemorySegment _x1);
+        }
 
-        int apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1, java.lang.foreign.MemorySegment _x2, long _x3, int _x4);
-        static MemorySegment allocate(setxattr fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$22.const$2, fi, constants$7.const$3, scope);
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(init.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(init.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
         }
-        static setxattr ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1, java.lang.foreign.MemorySegment __x2, long __x3, int __x4) -> {
-                try {
-                    return (int)constants$7.const$5.invokeExact(symbol, __x0, __x1, __x2, __x3, __x4);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static MemorySegment invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1) {
+            try {
+                return (MemorySegment) DOWN$MH.invokeExact(funcPtr, _x0, _x1);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
         }
     }
 
-    public static VarHandle setxattr$VH() {
-        return constants$22.const$3;
+    private static final AddressLayout init$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("init"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * void *(*init)(struct fuse3_conn_info *, struct fuse3_config *)
+     * }
+     */
+    public static final AddressLayout init$layout() {
+        return init$LAYOUT;
+    }
+
+    private static final long init$OFFSET = 216;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * void *(*init)(struct fuse3_conn_info *, struct fuse3_config *)
+     * }
+     */
+    public static final long init$offset() {
+        return init$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int (*setxattr)(char*,char*,char*,unsigned long long,int);
+     * {@snippet lang=c :
+     * void *(*init)(struct fuse3_conn_info *, struct fuse3_config *)
      * }
      */
-    public static MemorySegment setxattr$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$22.const$3.get(seg);
+    public static MemorySegment init(MemorySegment struct) {
+        return struct.get(init$LAYOUT, init$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int (*setxattr)(char*,char*,char*,unsigned long long,int);
+     * {@snippet lang=c :
+     * void *(*init)(struct fuse3_conn_info *, struct fuse3_config *)
      * }
      */
-    public static void setxattr$set(MemorySegment seg, MemorySegment x) {
-        constants$22.const$3.set(seg, x);
-    }
-    public static MemorySegment setxattr$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$22.const$3.get(seg.asSlice(index*sizeof()));
-    }
-    public static void setxattr$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$22.const$3.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static setxattr setxattr(MemorySegment segment, Arena scope) {
-        return setxattr.ofAddress(setxattr$get(segment), scope);
+    public static void init(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(init$LAYOUT, init$OFFSET, fieldValue);
     }
+
     /**
-     * {@snippet :
- * int (*getxattr)(char*,char*,char*,unsigned long long);
+     * {@snippet lang=c :
+     * void (*destroy)(void *)
      * }
      */
-    public interface getxattr {
+    public static class destroy {
+
+        destroy() {
+            // Should not be called directly
+        }
 
-        int apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1, java.lang.foreign.MemorySegment _x2, long _x3);
-        static MemorySegment allocate(getxattr fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$22.const$5, fi, constants$22.const$4, scope);
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            void apply(MemorySegment _x0);
         }
-        static getxattr ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1, java.lang.foreign.MemorySegment __x2, long __x3) -> {
-                try {
-                    return (int)constants$23.const$0.invokeExact(symbol, __x0, __x1, __x2, __x3);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.ofVoid(
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(destroy.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(destroy.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static void invoke(MemorySegment funcPtr,MemorySegment _x0) {
+            try {
+                 DOWN$MH.invokeExact(funcPtr, _x0);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
         }
     }
 
-    public static VarHandle getxattr$VH() {
-        return constants$23.const$1;
+    private static final AddressLayout destroy$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("destroy"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * void (*destroy)(void *)
+     * }
+     */
+    public static final AddressLayout destroy$layout() {
+        return destroy$LAYOUT;
+    }
+
+    private static final long destroy$OFFSET = 224;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * void (*destroy)(void *)
+     * }
+     */
+    public static final long destroy$offset() {
+        return destroy$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int (*getxattr)(char*,char*,char*,unsigned long long);
+     * {@snippet lang=c :
+     * void (*destroy)(void *)
      * }
      */
-    public static MemorySegment getxattr$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$23.const$1.get(seg);
+    public static MemorySegment destroy(MemorySegment struct) {
+        return struct.get(destroy$LAYOUT, destroy$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int (*getxattr)(char*,char*,char*,unsigned long long);
+     * {@snippet lang=c :
+     * void (*destroy)(void *)
      * }
      */
-    public static void getxattr$set(MemorySegment seg, MemorySegment x) {
-        constants$23.const$1.set(seg, x);
-    }
-    public static MemorySegment getxattr$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$23.const$1.get(seg.asSlice(index*sizeof()));
-    }
-    public static void getxattr$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$23.const$1.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static getxattr getxattr(MemorySegment segment, Arena scope) {
-        return getxattr.ofAddress(getxattr$get(segment), scope);
+    public static void destroy(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(destroy$LAYOUT, destroy$OFFSET, fieldValue);
     }
+
     /**
-     * {@snippet :
- * int (*listxattr)(char*,char*,unsigned long long);
+     * {@snippet lang=c :
+     * int (*access)(const char *, int)
      * }
      */
-    public interface listxattr {
+    public static class access {
 
-        int apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1, long _x2);
-        static MemorySegment allocate(listxattr fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$23.const$2, fi, constants$13.const$0, scope);
+        access() {
+            // Should not be called directly
         }
-        static listxattr ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1, long __x2) -> {
-                try {
-                    return (int)constants$13.const$2.invokeExact(symbol, __x0, __x1, __x2);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, int _x1);
+        }
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_INT
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(access.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(access.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, int _x1) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
         }
     }
 
-    public static VarHandle listxattr$VH() {
-        return constants$23.const$3;
+    private static final AddressLayout access$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("access"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*access)(const char *, int)
+     * }
+     */
+    public static final AddressLayout access$layout() {
+        return access$LAYOUT;
+    }
+
+    private static final long access$OFFSET = 232;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*access)(const char *, int)
+     * }
+     */
+    public static final long access$offset() {
+        return access$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int (*listxattr)(char*,char*,unsigned long long);
+     * {@snippet lang=c :
+     * int (*access)(const char *, int)
      * }
      */
-    public static MemorySegment listxattr$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$23.const$3.get(seg);
+    public static MemorySegment access(MemorySegment struct) {
+        return struct.get(access$LAYOUT, access$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int (*listxattr)(char*,char*,unsigned long long);
+     * {@snippet lang=c :
+     * int (*access)(const char *, int)
      * }
      */
-    public static void listxattr$set(MemorySegment seg, MemorySegment x) {
-        constants$23.const$3.set(seg, x);
-    }
-    public static MemorySegment listxattr$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$23.const$3.get(seg.asSlice(index*sizeof()));
-    }
-    public static void listxattr$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$23.const$3.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static listxattr listxattr(MemorySegment segment, Arena scope) {
-        return listxattr.ofAddress(listxattr$get(segment), scope);
+    public static void access(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(access$LAYOUT, access$OFFSET, fieldValue);
     }
+
     /**
-     * {@snippet :
- * int (*removexattr)(char*,char*);
+     * {@snippet lang=c :
+     * int (*create)(const char *, fuse_mode_t, struct fuse3_file_info *)
      * }
      */
-    public interface removexattr {
+    public static class create {
+
+        create() {
+            // Should not be called directly
+        }
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, int _x1, MemorySegment _x2);
+        }
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_INT,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(create.Function.class, "apply", $DESC);
 
-        int apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1);
-        static MemorySegment allocate(removexattr fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$23.const$4, fi, constants$16.const$0, scope);
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(create.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
         }
-        static removexattr ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1) -> {
-                try {
-                    return (int)constants$16.const$2.invokeExact(symbol, __x0, __x1);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, int _x1, MemorySegment _x2) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
         }
     }
 
-    public static VarHandle removexattr$VH() {
-        return constants$23.const$5;
+    private static final AddressLayout create$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("create"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*create)(const char *, fuse_mode_t, struct fuse3_file_info *)
+     * }
+     */
+    public static final AddressLayout create$layout() {
+        return create$LAYOUT;
+    }
+
+    private static final long create$OFFSET = 240;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*create)(const char *, fuse_mode_t, struct fuse3_file_info *)
+     * }
+     */
+    public static final long create$offset() {
+        return create$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int (*removexattr)(char*,char*);
+     * {@snippet lang=c :
+     * int (*create)(const char *, fuse_mode_t, struct fuse3_file_info *)
      * }
      */
-    public static MemorySegment removexattr$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$23.const$5.get(seg);
+    public static MemorySegment create(MemorySegment struct) {
+        return struct.get(create$LAYOUT, create$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int (*removexattr)(char*,char*);
+     * {@snippet lang=c :
+     * int (*create)(const char *, fuse_mode_t, struct fuse3_file_info *)
      * }
      */
-    public static void removexattr$set(MemorySegment seg, MemorySegment x) {
-        constants$23.const$5.set(seg, x);
-    }
-    public static MemorySegment removexattr$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$23.const$5.get(seg.asSlice(index*sizeof()));
-    }
-    public static void removexattr$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$23.const$5.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static removexattr removexattr(MemorySegment segment, Arena scope) {
-        return removexattr.ofAddress(removexattr$get(segment), scope);
+    public static void create(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(create$LAYOUT, create$OFFSET, fieldValue);
     }
+
     /**
-     * {@snippet :
- * int (*opendir)(char*,struct fuse3_file_info*);
+     * {@snippet lang=c :
+     * int (*lock)(const char *, struct fuse3_file_info *, int, struct fuse_flock *)
      * }
      */
-    public interface opendir {
+    public static class lock {
+
+        lock() {
+            // Should not be called directly
+        }
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, MemorySegment _x1, int _x2, MemorySegment _x3);
+        }
 
-        int apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1);
-        static MemorySegment allocate(opendir fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$24.const$0, fi, constants$16.const$0, scope);
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER,
+            fuse_h.C_INT,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(lock.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(lock.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
         }
-        static opendir ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1) -> {
-                try {
-                    return (int)constants$16.const$2.invokeExact(symbol, __x0, __x1);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1, int _x2, MemorySegment _x3) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2, _x3);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
         }
     }
 
-    public static VarHandle opendir$VH() {
-        return constants$24.const$1;
+    private static final AddressLayout lock$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("lock"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*lock)(const char *, struct fuse3_file_info *, int, struct fuse_flock *)
+     * }
+     */
+    public static final AddressLayout lock$layout() {
+        return lock$LAYOUT;
+    }
+
+    private static final long lock$OFFSET = 248;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*lock)(const char *, struct fuse3_file_info *, int, struct fuse_flock *)
+     * }
+     */
+    public static final long lock$offset() {
+        return lock$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int (*opendir)(char*,struct fuse3_file_info*);
+     * {@snippet lang=c :
+     * int (*lock)(const char *, struct fuse3_file_info *, int, struct fuse_flock *)
      * }
      */
-    public static MemorySegment opendir$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$24.const$1.get(seg);
+    public static MemorySegment lock(MemorySegment struct) {
+        return struct.get(lock$LAYOUT, lock$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int (*opendir)(char*,struct fuse3_file_info*);
+     * {@snippet lang=c :
+     * int (*lock)(const char *, struct fuse3_file_info *, int, struct fuse_flock *)
      * }
      */
-    public static void opendir$set(MemorySegment seg, MemorySegment x) {
-        constants$24.const$1.set(seg, x);
+    public static void lock(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(lock$LAYOUT, lock$OFFSET, fieldValue);
     }
-    public static MemorySegment opendir$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$24.const$1.get(seg.asSlice(index*sizeof()));
-    }
-    public static void opendir$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$24.const$1.set(seg.asSlice(index*sizeof()), x);
+
+    /**
+     * {@snippet lang=c :
+     * int (*utimens)(const char *, const struct fuse_timespec *, struct fuse3_file_info *)
+     * }
+     */
+    public static class utimens {
+
+        utimens() {
+            // Should not be called directly
+        }
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, MemorySegment _x1, MemorySegment _x2);
+        }
+
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(utimens.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(utimens.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1, MemorySegment _x2) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
     }
-    public static opendir opendir(MemorySegment segment, Arena scope) {
-        return opendir.ofAddress(opendir$get(segment), scope);
+
+    private static final AddressLayout utimens$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("utimens"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*utimens)(const char *, const struct fuse_timespec *, struct fuse3_file_info *)
+     * }
+     */
+    public static final AddressLayout utimens$layout() {
+        return utimens$LAYOUT;
     }
+
+    private static final long utimens$OFFSET = 256;
+
     /**
-     * {@snippet :
- * int (*readdir)(char*,void*,int (*)(void*,char*,struct fuse_stat*,long long,enum fuse3_fill_dir_flags),long long,struct fuse3_file_info*,enum fuse3_readdir_flags);
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*utimens)(const char *, const struct fuse_timespec *, struct fuse3_file_info *)
      * }
      */
-    public interface readdir {
-
-        int apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1, java.lang.foreign.MemorySegment _x2, long _x3, java.lang.foreign.MemorySegment _x4, int _x5);
-        static MemorySegment allocate(readdir fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$24.const$3, fi, constants$24.const$2, scope);
-        }
-        static readdir ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1, java.lang.foreign.MemorySegment __x2, long __x3, java.lang.foreign.MemorySegment __x4, int __x5) -> {
-                try {
-                    return (int)constants$24.const$4.invokeExact(symbol, __x0, __x1, __x2, __x3, __x4, __x5);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
-        }
+    public static final long utimens$offset() {
+        return utimens$OFFSET;
     }
 
-    public static VarHandle readdir$VH() {
-        return constants$24.const$5;
-    }
     /**
      * Getter for field:
-     * {@snippet :
-     * int (*readdir)(char*,void*,int (*)(void*,char*,struct fuse_stat*,long long,enum fuse3_fill_dir_flags),long long,struct fuse3_file_info*,enum fuse3_readdir_flags);
+     * {@snippet lang=c :
+     * int (*utimens)(const char *, const struct fuse_timespec *, struct fuse3_file_info *)
      * }
      */
-    public static MemorySegment readdir$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$24.const$5.get(seg);
+    public static MemorySegment utimens(MemorySegment struct) {
+        return struct.get(utimens$LAYOUT, utimens$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int (*readdir)(char*,void*,int (*)(void*,char*,struct fuse_stat*,long long,enum fuse3_fill_dir_flags),long long,struct fuse3_file_info*,enum fuse3_readdir_flags);
+     * {@snippet lang=c :
+     * int (*utimens)(const char *, const struct fuse_timespec *, struct fuse3_file_info *)
      * }
      */
-    public static void readdir$set(MemorySegment seg, MemorySegment x) {
-        constants$24.const$5.set(seg, x);
-    }
-    public static MemorySegment readdir$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$24.const$5.get(seg.asSlice(index*sizeof()));
-    }
-    public static void readdir$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$24.const$5.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static readdir readdir(MemorySegment segment, Arena scope) {
-        return readdir.ofAddress(readdir$get(segment), scope);
+    public static void utimens(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(utimens$LAYOUT, utimens$OFFSET, fieldValue);
     }
+
     /**
-     * {@snippet :
- * int (*releasedir)(char*,struct fuse3_file_info*);
+     * {@snippet lang=c :
+     * int (*bmap)(const char *, size_t, uint64_t *)
      * }
      */
-    public interface releasedir {
+    public static class bmap {
 
-        int apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1);
-        static MemorySegment allocate(releasedir fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$25.const$0, fi, constants$16.const$0, scope);
+        bmap() {
+            // Should not be called directly
         }
-        static releasedir ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1) -> {
-                try {
-                    return (int)constants$16.const$2.invokeExact(symbol, __x0, __x1);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, long _x1, MemorySegment _x2);
         }
-    }
 
-    public static VarHandle releasedir$VH() {
-        return constants$25.const$1;
-    }
-    /**
-     * Getter for field:
-     * {@snippet :
-     * int (*releasedir)(char*,struct fuse3_file_info*);
-     * }
-     */
-    public static MemorySegment releasedir$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$25.const$1.get(seg);
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_LONG_LONG,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(bmap.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(bmap.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, long _x1, MemorySegment _x2) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
     }
+
+    private static final AddressLayout bmap$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("bmap"));
+
     /**
-     * Setter for field:
-     * {@snippet :
-     * int (*releasedir)(char*,struct fuse3_file_info*);
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*bmap)(const char *, size_t, uint64_t *)
      * }
      */
-    public static void releasedir$set(MemorySegment seg, MemorySegment x) {
-        constants$25.const$1.set(seg, x);
-    }
-    public static MemorySegment releasedir$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$25.const$1.get(seg.asSlice(index*sizeof()));
-    }
-    public static void releasedir$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$25.const$1.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static releasedir releasedir(MemorySegment segment, Arena scope) {
-        return releasedir.ofAddress(releasedir$get(segment), scope);
+    public static final AddressLayout bmap$layout() {
+        return bmap$LAYOUT;
     }
+
+    private static final long bmap$OFFSET = 264;
+
     /**
-     * {@snippet :
- * int (*fsyncdir)(char*,int,struct fuse3_file_info*);
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*bmap)(const char *, size_t, uint64_t *)
      * }
      */
-    public interface fsyncdir {
-
-        int apply(java.lang.foreign.MemorySegment _x0, int _x1, java.lang.foreign.MemorySegment _x2);
-        static MemorySegment allocate(fsyncdir fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$25.const$2, fi, constants$17.const$4, scope);
-        }
-        static fsyncdir ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, int __x1, java.lang.foreign.MemorySegment __x2) -> {
-                try {
-                    return (int)constants$18.const$0.invokeExact(symbol, __x0, __x1, __x2);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
-        }
+    public static final long bmap$offset() {
+        return bmap$OFFSET;
     }
 
-    public static VarHandle fsyncdir$VH() {
-        return constants$25.const$3;
-    }
     /**
      * Getter for field:
-     * {@snippet :
-     * int (*fsyncdir)(char*,int,struct fuse3_file_info*);
+     * {@snippet lang=c :
+     * int (*bmap)(const char *, size_t, uint64_t *)
      * }
      */
-    public static MemorySegment fsyncdir$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$25.const$3.get(seg);
+    public static MemorySegment bmap(MemorySegment struct) {
+        return struct.get(bmap$LAYOUT, bmap$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int (*fsyncdir)(char*,int,struct fuse3_file_info*);
+     * {@snippet lang=c :
+     * int (*bmap)(const char *, size_t, uint64_t *)
      * }
      */
-    public static void fsyncdir$set(MemorySegment seg, MemorySegment x) {
-        constants$25.const$3.set(seg, x);
-    }
-    public static MemorySegment fsyncdir$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$25.const$3.get(seg.asSlice(index*sizeof()));
-    }
-    public static void fsyncdir$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$25.const$3.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static fsyncdir fsyncdir(MemorySegment segment, Arena scope) {
-        return fsyncdir.ofAddress(fsyncdir$get(segment), scope);
+    public static void bmap(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(bmap$LAYOUT, bmap$OFFSET, fieldValue);
     }
+
     /**
-     * {@snippet :
- * void* (*init)(struct fuse3_conn_info*,struct fuse3_config*);
+     * {@snippet lang=c :
+     * int (*ioctl)(const char *, int, void *, struct fuse3_file_info *, unsigned int, void *)
      * }
      */
-    public interface init {
+    public static class ioctl {
 
-        java.lang.foreign.MemorySegment apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1);
-        static MemorySegment allocate(init fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$25.const$5, fi, constants$25.const$4, scope);
+        ioctl() {
+            // Should not be called directly
         }
-        static init ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1) -> {
-                try {
-                    return (java.lang.foreign.MemorySegment)constants$26.const$0.invokeExact(symbol, __x0, __x1);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, int _x1, MemorySegment _x2, MemorySegment _x3, int _x4, MemorySegment _x5);
         }
-    }
 
-    public static VarHandle init$VH() {
-        return constants$26.const$1;
-    }
-    /**
-     * Getter for field:
-     * {@snippet :
-     * void* (*init)(struct fuse3_conn_info*,struct fuse3_config*);
-     * }
-     */
-    public static MemorySegment init$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$26.const$1.get(seg);
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER,
+            fuse_h.C_INT,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(ioctl.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(ioctl.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, int _x1, MemorySegment _x2, MemorySegment _x3, int _x4, MemorySegment _x5) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2, _x3, _x4, _x5);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
     }
+
+    private static final AddressLayout ioctl$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("ioctl"));
+
     /**
-     * Setter for field:
-     * {@snippet :
-     * void* (*init)(struct fuse3_conn_info*,struct fuse3_config*);
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*ioctl)(const char *, int, void *, struct fuse3_file_info *, unsigned int, void *)
      * }
      */
-    public static void init$set(MemorySegment seg, MemorySegment x) {
-        constants$26.const$1.set(seg, x);
-    }
-    public static MemorySegment init$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$26.const$1.get(seg.asSlice(index*sizeof()));
-    }
-    public static void init$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$26.const$1.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static init init(MemorySegment segment, Arena scope) {
-        return init.ofAddress(init$get(segment), scope);
+    public static final AddressLayout ioctl$layout() {
+        return ioctl$LAYOUT;
     }
+
+    private static final long ioctl$OFFSET = 272;
+
     /**
-     * {@snippet :
- * void (*destroy)(void*);
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*ioctl)(const char *, int, void *, struct fuse3_file_info *, unsigned int, void *)
      * }
      */
-    public interface destroy {
-
-        void apply(java.lang.foreign.MemorySegment _x0);
-        static MemorySegment allocate(destroy fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$26.const$3, fi, constants$26.const$2, scope);
-        }
-        static destroy ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0) -> {
-                try {
-                    constants$26.const$4.invokeExact(symbol, __x0);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
-        }
+    public static final long ioctl$offset() {
+        return ioctl$OFFSET;
     }
 
-    public static VarHandle destroy$VH() {
-        return constants$26.const$5;
-    }
     /**
      * Getter for field:
-     * {@snippet :
-     * void (*destroy)(void*);
+     * {@snippet lang=c :
+     * int (*ioctl)(const char *, int, void *, struct fuse3_file_info *, unsigned int, void *)
      * }
      */
-    public static MemorySegment destroy$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$26.const$5.get(seg);
+    public static MemorySegment ioctl(MemorySegment struct) {
+        return struct.get(ioctl$LAYOUT, ioctl$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * void (*destroy)(void*);
+     * {@snippet lang=c :
+     * int (*ioctl)(const char *, int, void *, struct fuse3_file_info *, unsigned int, void *)
      * }
      */
-    public static void destroy$set(MemorySegment seg, MemorySegment x) {
-        constants$26.const$5.set(seg, x);
-    }
-    public static MemorySegment destroy$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$26.const$5.get(seg.asSlice(index*sizeof()));
-    }
-    public static void destroy$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$26.const$5.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static destroy destroy(MemorySegment segment, Arena scope) {
-        return destroy.ofAddress(destroy$get(segment), scope);
+    public static void ioctl(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(ioctl$LAYOUT, ioctl$OFFSET, fieldValue);
     }
+
     /**
-     * {@snippet :
- * int (*access)(char*,int);
+     * {@snippet lang=c :
+     * int (*poll)(const char *, struct fuse3_file_info *, struct fuse3_pollhandle *, unsigned int *)
      * }
      */
-    public interface access {
+    public static class poll {
 
-        int apply(java.lang.foreign.MemorySegment _x0, int _x1);
-        static MemorySegment allocate(access fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$27.const$0, fi, constants$14.const$2, scope);
+        poll() {
+            // Should not be called directly
         }
-        static access ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, int __x1) -> {
-                try {
-                    return (int)constants$14.const$4.invokeExact(symbol, __x0, __x1);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, MemorySegment _x1, MemorySegment _x2, MemorySegment _x3);
         }
-    }
 
-    public static VarHandle access$VH() {
-        return constants$27.const$1;
-    }
-    /**
-     * Getter for field:
-     * {@snippet :
-     * int (*access)(char*,int);
-     * }
-     */
-    public static MemorySegment access$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$27.const$1.get(seg);
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(poll.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(poll.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1, MemorySegment _x2, MemorySegment _x3) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2, _x3);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
     }
+
+    private static final AddressLayout poll$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("poll"));
+
     /**
-     * Setter for field:
-     * {@snippet :
-     * int (*access)(char*,int);
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*poll)(const char *, struct fuse3_file_info *, struct fuse3_pollhandle *, unsigned int *)
      * }
      */
-    public static void access$set(MemorySegment seg, MemorySegment x) {
-        constants$27.const$1.set(seg, x);
-    }
-    public static MemorySegment access$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$27.const$1.get(seg.asSlice(index*sizeof()));
-    }
-    public static void access$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$27.const$1.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static access access(MemorySegment segment, Arena scope) {
-        return access.ofAddress(access$get(segment), scope);
+    public static final AddressLayout poll$layout() {
+        return poll$LAYOUT;
     }
+
+    private static final long poll$OFFSET = 280;
+
     /**
-     * {@snippet :
- * int (*create)(char*,unsigned int,struct fuse3_file_info*);
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*poll)(const char *, struct fuse3_file_info *, struct fuse3_pollhandle *, unsigned int *)
      * }
      */
-    public interface create {
-
-        int apply(java.lang.foreign.MemorySegment _x0, int _x1, java.lang.foreign.MemorySegment _x2);
-        static MemorySegment allocate(create fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$27.const$2, fi, constants$17.const$4, scope);
-        }
-        static create ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, int __x1, java.lang.foreign.MemorySegment __x2) -> {
-                try {
-                    return (int)constants$18.const$0.invokeExact(symbol, __x0, __x1, __x2);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
-        }
+    public static final long poll$offset() {
+        return poll$OFFSET;
     }
 
-    public static VarHandle create$VH() {
-        return constants$27.const$3;
-    }
     /**
      * Getter for field:
-     * {@snippet :
-     * int (*create)(char*,unsigned int,struct fuse3_file_info*);
+     * {@snippet lang=c :
+     * int (*poll)(const char *, struct fuse3_file_info *, struct fuse3_pollhandle *, unsigned int *)
      * }
      */
-    public static MemorySegment create$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$27.const$3.get(seg);
+    public static MemorySegment poll(MemorySegment struct) {
+        return struct.get(poll$LAYOUT, poll$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int (*create)(char*,unsigned int,struct fuse3_file_info*);
+     * {@snippet lang=c :
+     * int (*poll)(const char *, struct fuse3_file_info *, struct fuse3_pollhandle *, unsigned int *)
      * }
      */
-    public static void create$set(MemorySegment seg, MemorySegment x) {
-        constants$27.const$3.set(seg, x);
-    }
-    public static MemorySegment create$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$27.const$3.get(seg.asSlice(index*sizeof()));
-    }
-    public static void create$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$27.const$3.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static create create(MemorySegment segment, Arena scope) {
-        return create.ofAddress(create$get(segment), scope);
+    public static void poll(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(poll$LAYOUT, poll$OFFSET, fieldValue);
     }
+
     /**
-     * {@snippet :
- * int (*lock)(char*,struct fuse3_file_info*,int,struct fuse_flock*);
+     * {@snippet lang=c :
+     * int (*write_buf)(const char *, struct fuse3_bufvec *, fuse_off_t, struct fuse3_file_info *)
      * }
      */
-    public interface lock {
+    public static class write_buf {
 
-        int apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1, int _x2, java.lang.foreign.MemorySegment _x3);
-        static MemorySegment allocate(lock fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$27.const$5, fi, constants$27.const$4, scope);
+        write_buf() {
+            // Should not be called directly
         }
-        static lock ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1, int __x2, java.lang.foreign.MemorySegment __x3) -> {
-                try {
-                    return (int)constants$28.const$0.invokeExact(symbol, __x0, __x1, __x2, __x3);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, MemorySegment _x1, long _x2, MemorySegment _x3);
         }
-    }
 
-    public static VarHandle lock$VH() {
-        return constants$28.const$1;
-    }
-    /**
-     * Getter for field:
-     * {@snippet :
-     * int (*lock)(char*,struct fuse3_file_info*,int,struct fuse_flock*);
-     * }
-     */
-    public static MemorySegment lock$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$28.const$1.get(seg);
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER,
+            fuse_h.C_LONG_LONG,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(write_buf.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(write_buf.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1, long _x2, MemorySegment _x3) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2, _x3);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
     }
+
+    private static final AddressLayout write_buf$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("write_buf"));
+
     /**
-     * Setter for field:
-     * {@snippet :
-     * int (*lock)(char*,struct fuse3_file_info*,int,struct fuse_flock*);
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*write_buf)(const char *, struct fuse3_bufvec *, fuse_off_t, struct fuse3_file_info *)
      * }
      */
-    public static void lock$set(MemorySegment seg, MemorySegment x) {
-        constants$28.const$1.set(seg, x);
-    }
-    public static MemorySegment lock$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$28.const$1.get(seg.asSlice(index*sizeof()));
-    }
-    public static void lock$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$28.const$1.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static lock lock(MemorySegment segment, Arena scope) {
-        return lock.ofAddress(lock$get(segment), scope);
+    public static final AddressLayout write_buf$layout() {
+        return write_buf$LAYOUT;
     }
+
+    private static final long write_buf$OFFSET = 288;
+
     /**
-     * {@snippet :
- * int (*utimens)(char*,struct fuse_timespec*,struct fuse3_file_info*);
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*write_buf)(const char *, struct fuse3_bufvec *, fuse_off_t, struct fuse3_file_info *)
      * }
      */
-    public interface utimens {
-
-        int apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1, java.lang.foreign.MemorySegment _x2);
-        static MemorySegment allocate(utimens fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$28.const$2, fi, constants$12.const$2, scope);
-        }
-        static utimens ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1, java.lang.foreign.MemorySegment __x2) -> {
-                try {
-                    return (int)constants$12.const$4.invokeExact(symbol, __x0, __x1, __x2);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
-        }
+    public static final long write_buf$offset() {
+        return write_buf$OFFSET;
     }
 
-    public static VarHandle utimens$VH() {
-        return constants$28.const$3;
-    }
     /**
      * Getter for field:
-     * {@snippet :
-     * int (*utimens)(char*,struct fuse_timespec*,struct fuse3_file_info*);
+     * {@snippet lang=c :
+     * int (*write_buf)(const char *, struct fuse3_bufvec *, fuse_off_t, struct fuse3_file_info *)
      * }
      */
-    public static MemorySegment utimens$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$28.const$3.get(seg);
+    public static MemorySegment write_buf(MemorySegment struct) {
+        return struct.get(write_buf$LAYOUT, write_buf$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int (*utimens)(char*,struct fuse_timespec*,struct fuse3_file_info*);
+     * {@snippet lang=c :
+     * int (*write_buf)(const char *, struct fuse3_bufvec *, fuse_off_t, struct fuse3_file_info *)
      * }
      */
-    public static void utimens$set(MemorySegment seg, MemorySegment x) {
-        constants$28.const$3.set(seg, x);
-    }
-    public static MemorySegment utimens$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$28.const$3.get(seg.asSlice(index*sizeof()));
-    }
-    public static void utimens$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$28.const$3.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static utimens utimens(MemorySegment segment, Arena scope) {
-        return utimens.ofAddress(utimens$get(segment), scope);
+    public static void write_buf(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(write_buf$LAYOUT, write_buf$OFFSET, fieldValue);
     }
+
     /**
-     * {@snippet :
- * int (*bmap)(char*,unsigned long long,unsigned long long*);
+     * {@snippet lang=c :
+     * int (*read_buf)(const char *, struct fuse3_bufvec **, size_t, fuse_off_t, struct fuse3_file_info *)
      * }
      */
-    public interface bmap {
+    public static class read_buf {
 
-        int apply(java.lang.foreign.MemorySegment _x0, long _x1, java.lang.foreign.MemorySegment _x2);
-        static MemorySegment allocate(bmap fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$28.const$4, fi, constants$19.const$0, scope);
+        read_buf() {
+            // Should not be called directly
         }
-        static bmap ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, long __x1, java.lang.foreign.MemorySegment __x2) -> {
-                try {
-                    return (int)constants$19.const$2.invokeExact(symbol, __x0, __x1, __x2);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, MemorySegment _x1, long _x2, long _x3, MemorySegment _x4);
         }
-    }
 
-    public static VarHandle bmap$VH() {
-        return constants$28.const$5;
-    }
-    /**
-     * Getter for field:
-     * {@snippet :
-     * int (*bmap)(char*,unsigned long long,unsigned long long*);
-     * }
-     */
-    public static MemorySegment bmap$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$28.const$5.get(seg);
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER,
+            fuse_h.C_LONG_LONG,
+            fuse_h.C_LONG_LONG,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(read_buf.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(read_buf.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1, long _x2, long _x3, MemorySegment _x4) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2, _x3, _x4);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
     }
+
+    private static final AddressLayout read_buf$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("read_buf"));
+
     /**
-     * Setter for field:
-     * {@snippet :
-     * int (*bmap)(char*,unsigned long long,unsigned long long*);
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*read_buf)(const char *, struct fuse3_bufvec **, size_t, fuse_off_t, struct fuse3_file_info *)
      * }
      */
-    public static void bmap$set(MemorySegment seg, MemorySegment x) {
-        constants$28.const$5.set(seg, x);
-    }
-    public static MemorySegment bmap$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$28.const$5.get(seg.asSlice(index*sizeof()));
-    }
-    public static void bmap$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$28.const$5.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static bmap bmap(MemorySegment segment, Arena scope) {
-        return bmap.ofAddress(bmap$get(segment), scope);
+    public static final AddressLayout read_buf$layout() {
+        return read_buf$LAYOUT;
     }
+
+    private static final long read_buf$OFFSET = 296;
+
     /**
-     * {@snippet :
- * int (*ioctl)(char*,int,void*,struct fuse3_file_info*,unsigned int,void*);
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*read_buf)(const char *, struct fuse3_bufvec **, size_t, fuse_off_t, struct fuse3_file_info *)
      * }
      */
-    public interface ioctl {
-
-        int apply(java.lang.foreign.MemorySegment _x0, int _x1, java.lang.foreign.MemorySegment _x2, java.lang.foreign.MemorySegment _x3, int _x4, java.lang.foreign.MemorySegment _x5);
-        static MemorySegment allocate(ioctl fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$29.const$1, fi, constants$29.const$0, scope);
-        }
-        static ioctl ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, int __x1, java.lang.foreign.MemorySegment __x2, java.lang.foreign.MemorySegment __x3, int __x4, java.lang.foreign.MemorySegment __x5) -> {
-                try {
-                    return (int)constants$29.const$2.invokeExact(symbol, __x0, __x1, __x2, __x3, __x4, __x5);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
-        }
+    public static final long read_buf$offset() {
+        return read_buf$OFFSET;
     }
 
-    public static VarHandle ioctl$VH() {
-        return constants$29.const$3;
-    }
     /**
      * Getter for field:
-     * {@snippet :
-     * int (*ioctl)(char*,int,void*,struct fuse3_file_info*,unsigned int,void*);
+     * {@snippet lang=c :
+     * int (*read_buf)(const char *, struct fuse3_bufvec **, size_t, fuse_off_t, struct fuse3_file_info *)
      * }
      */
-    public static MemorySegment ioctl$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$29.const$3.get(seg);
+    public static MemorySegment read_buf(MemorySegment struct) {
+        return struct.get(read_buf$LAYOUT, read_buf$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int (*ioctl)(char*,int,void*,struct fuse3_file_info*,unsigned int,void*);
+     * {@snippet lang=c :
+     * int (*read_buf)(const char *, struct fuse3_bufvec **, size_t, fuse_off_t, struct fuse3_file_info *)
      * }
      */
-    public static void ioctl$set(MemorySegment seg, MemorySegment x) {
-        constants$29.const$3.set(seg, x);
-    }
-    public static MemorySegment ioctl$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$29.const$3.get(seg.asSlice(index*sizeof()));
-    }
-    public static void ioctl$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$29.const$3.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static ioctl ioctl(MemorySegment segment, Arena scope) {
-        return ioctl.ofAddress(ioctl$get(segment), scope);
+    public static void read_buf(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(read_buf$LAYOUT, read_buf$OFFSET, fieldValue);
     }
+
     /**
-     * {@snippet :
- * int (*poll)(char*,struct fuse3_file_info*,struct fuse3_pollhandle*,unsigned int*);
+     * {@snippet lang=c :
+     * int (*flock)(const char *, struct fuse3_file_info *, int)
      * }
      */
-    public interface poll {
+    public static class flock {
 
-        int apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1, java.lang.foreign.MemorySegment _x2, java.lang.foreign.MemorySegment _x3);
-        static MemorySegment allocate(poll fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$29.const$5, fi, constants$29.const$4, scope);
+        flock() {
+            // Should not be called directly
         }
-        static poll ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1, java.lang.foreign.MemorySegment __x2, java.lang.foreign.MemorySegment __x3) -> {
-                try {
-                    return (int)constants$30.const$0.invokeExact(symbol, __x0, __x1, __x2, __x3);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, MemorySegment _x1, int _x2);
         }
-    }
 
-    public static VarHandle poll$VH() {
-        return constants$30.const$1;
-    }
-    /**
-     * Getter for field:
-     * {@snippet :
-     * int (*poll)(char*,struct fuse3_file_info*,struct fuse3_pollhandle*,unsigned int*);
-     * }
-     */
-    public static MemorySegment poll$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$30.const$1.get(seg);
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER,
+            fuse_h.C_INT
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(flock.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(flock.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1, int _x2) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
     }
+
+    private static final AddressLayout flock$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("flock"));
+
     /**
-     * Setter for field:
-     * {@snippet :
-     * int (*poll)(char*,struct fuse3_file_info*,struct fuse3_pollhandle*,unsigned int*);
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*flock)(const char *, struct fuse3_file_info *, int)
      * }
      */
-    public static void poll$set(MemorySegment seg, MemorySegment x) {
-        constants$30.const$1.set(seg, x);
-    }
-    public static MemorySegment poll$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$30.const$1.get(seg.asSlice(index*sizeof()));
-    }
-    public static void poll$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$30.const$1.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static poll poll(MemorySegment segment, Arena scope) {
-        return poll.ofAddress(poll$get(segment), scope);
+    public static final AddressLayout flock$layout() {
+        return flock$LAYOUT;
     }
+
+    private static final long flock$OFFSET = 304;
+
     /**
-     * {@snippet :
- * int (*write_buf)(char*,struct fuse3_bufvec*,long long,struct fuse3_file_info*);
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*flock)(const char *, struct fuse3_file_info *, int)
      * }
      */
-    public interface write_buf {
-
-        int apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1, long _x2, java.lang.foreign.MemorySegment _x3);
-        static MemorySegment allocate(write_buf fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$30.const$3, fi, constants$30.const$2, scope);
-        }
-        static write_buf ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1, long __x2, java.lang.foreign.MemorySegment __x3) -> {
-                try {
-                    return (int)constants$30.const$4.invokeExact(symbol, __x0, __x1, __x2, __x3);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
-        }
+    public static final long flock$offset() {
+        return flock$OFFSET;
     }
 
-    public static VarHandle write_buf$VH() {
-        return constants$30.const$5;
-    }
     /**
      * Getter for field:
-     * {@snippet :
-     * int (*write_buf)(char*,struct fuse3_bufvec*,long long,struct fuse3_file_info*);
+     * {@snippet lang=c :
+     * int (*flock)(const char *, struct fuse3_file_info *, int)
      * }
      */
-    public static MemorySegment write_buf$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$30.const$5.get(seg);
+    public static MemorySegment flock(MemorySegment struct) {
+        return struct.get(flock$LAYOUT, flock$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int (*write_buf)(char*,struct fuse3_bufvec*,long long,struct fuse3_file_info*);
+     * {@snippet lang=c :
+     * int (*flock)(const char *, struct fuse3_file_info *, int)
      * }
      */
-    public static void write_buf$set(MemorySegment seg, MemorySegment x) {
-        constants$30.const$5.set(seg, x);
-    }
-    public static MemorySegment write_buf$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$30.const$5.get(seg.asSlice(index*sizeof()));
-    }
-    public static void write_buf$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$30.const$5.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static write_buf write_buf(MemorySegment segment, Arena scope) {
-        return write_buf.ofAddress(write_buf$get(segment), scope);
+    public static void flock(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(flock$LAYOUT, flock$OFFSET, fieldValue);
     }
+
     /**
-     * {@snippet :
- * int (*read_buf)(char*,struct fuse3_bufvec**,unsigned long long,long long,struct fuse3_file_info*);
+     * {@snippet lang=c :
+     * int (*fallocate)(const char *, int, fuse_off_t, fuse_off_t, struct fuse3_file_info *)
      * }
      */
-    public interface read_buf {
+    public static class fallocate {
 
-        int apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1, long _x2, long _x3, java.lang.foreign.MemorySegment _x4);
-        static MemorySegment allocate(read_buf fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$31.const$0, fi, constants$20.const$0, scope);
+        fallocate() {
+            // Should not be called directly
         }
-        static read_buf ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1, long __x2, long __x3, java.lang.foreign.MemorySegment __x4) -> {
-                try {
-                    return (int)constants$20.const$2.invokeExact(symbol, __x0, __x1, __x2, __x3, __x4);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
+
+        /**
+         * The function pointer signature, expressed as a functional interface
+         */
+        public interface Function {
+            int apply(MemorySegment _x0, int _x1, long _x2, long _x3, MemorySegment _x4);
         }
-    }
 
-    public static VarHandle read_buf$VH() {
-        return constants$31.const$1;
-    }
-    /**
-     * Getter for field:
-     * {@snippet :
-     * int (*read_buf)(char*,struct fuse3_bufvec**,unsigned long long,long long,struct fuse3_file_info*);
-     * }
-     */
-    public static MemorySegment read_buf$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$31.const$1.get(seg);
+        private static final FunctionDescriptor $DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_INT,
+            fuse_h.C_LONG_LONG,
+            fuse_h.C_LONG_LONG,
+            fuse_h.C_POINTER
+        );
+
+        /**
+         * The descriptor of this function pointer
+         */
+        public static FunctionDescriptor descriptor() {
+            return $DESC;
+        }
+
+        private static final MethodHandle UP$MH = fuse_h.upcallHandle(fallocate.Function.class, "apply", $DESC);
+
+        /**
+         * Allocates a new upcall stub, whose implementation is defined by {@code fi}.
+         * The lifetime of the returned segment is managed by {@code arena}
+         */
+        public static MemorySegment allocate(fallocate.Function fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena);
+        }
+
+        private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC);
+
+        /**
+         * Invoke the upcall stub {@code funcPtr}, with given parameters
+         */
+        public static int invoke(MemorySegment funcPtr,MemorySegment _x0, int _x1, long _x2, long _x3, MemorySegment _x4) {
+            try {
+                return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2, _x3, _x4);
+            } catch (Throwable ex$) {
+                throw new AssertionError("should not reach here", ex$);
+            }
+        }
     }
+
+    private static final AddressLayout fallocate$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("fallocate"));
+
     /**
-     * Setter for field:
-     * {@snippet :
-     * int (*read_buf)(char*,struct fuse3_bufvec**,unsigned long long,long long,struct fuse3_file_info*);
+     * Layout for field:
+     * {@snippet lang=c :
+     * int (*fallocate)(const char *, int, fuse_off_t, fuse_off_t, struct fuse3_file_info *)
      * }
      */
-    public static void read_buf$set(MemorySegment seg, MemorySegment x) {
-        constants$31.const$1.set(seg, x);
-    }
-    public static MemorySegment read_buf$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$31.const$1.get(seg.asSlice(index*sizeof()));
-    }
-    public static void read_buf$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$31.const$1.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static read_buf read_buf(MemorySegment segment, Arena scope) {
-        return read_buf.ofAddress(read_buf$get(segment), scope);
+    public static final AddressLayout fallocate$layout() {
+        return fallocate$LAYOUT;
     }
+
+    private static final long fallocate$OFFSET = 312;
+
     /**
-     * {@snippet :
- * int (*flock)(char*,struct fuse3_file_info*,int);
+     * Offset for field:
+     * {@snippet lang=c :
+     * int (*fallocate)(const char *, int, fuse_off_t, fuse_off_t, struct fuse3_file_info *)
      * }
      */
-    public interface flock {
-
-        int apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1, int _x2);
-        static MemorySegment allocate(flock fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$31.const$2, fi, constants$16.const$4, scope);
-        }
-        static flock ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1, int __x2) -> {
-                try {
-                    return (int)constants$17.const$0.invokeExact(symbol, __x0, __x1, __x2);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
-        }
+    public static final long fallocate$offset() {
+        return fallocate$OFFSET;
     }
 
-    public static VarHandle flock$VH() {
-        return constants$31.const$3;
-    }
     /**
      * Getter for field:
-     * {@snippet :
-     * int (*flock)(char*,struct fuse3_file_info*,int);
+     * {@snippet lang=c :
+     * int (*fallocate)(const char *, int, fuse_off_t, fuse_off_t, struct fuse3_file_info *)
      * }
      */
-    public static MemorySegment flock$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$31.const$3.get(seg);
+    public static MemorySegment fallocate(MemorySegment struct) {
+        return struct.get(fallocate$LAYOUT, fallocate$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int (*flock)(char*,struct fuse3_file_info*,int);
+     * {@snippet lang=c :
+     * int (*fallocate)(const char *, int, fuse_off_t, fuse_off_t, struct fuse3_file_info *)
      * }
      */
-    public static void flock$set(MemorySegment seg, MemorySegment x) {
-        constants$31.const$3.set(seg, x);
+    public static void fallocate(MemorySegment struct, MemorySegment fieldValue) {
+        struct.set(fallocate$LAYOUT, fallocate$OFFSET, fieldValue);
     }
-    public static MemorySegment flock$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$31.const$3.get(seg.asSlice(index*sizeof()));
-    }
-    public static void flock$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$31.const$3.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static flock flock(MemorySegment segment, Arena scope) {
-        return flock.ofAddress(flock$get(segment), scope);
+
+    /**
+     * Obtains a slice of {@code arrayParam} which selects the array element at {@code index}.
+     * The returned segment has address {@code arrayParam.address() + index * layout().byteSize()}
+     */
+    public static MemorySegment asSlice(MemorySegment array, long index) {
+        return array.asSlice(layout().byteSize() * index);
     }
+
     /**
-     * {@snippet :
- * int (*fallocate)(char*,int,long long,long long,struct fuse3_file_info*);
-     * }
+     * The size (in bytes) of this struct
      */
-    public interface fallocate {
+    public static long sizeof() { return layout().byteSize(); }
 
-        int apply(java.lang.foreign.MemorySegment _x0, int _x1, long _x2, long _x3, java.lang.foreign.MemorySegment _x4);
-        static MemorySegment allocate(fallocate fi, Arena scope) {
-            return RuntimeHelper.upcallStub(constants$31.const$5, fi, constants$31.const$4, scope);
-        }
-        static fallocate ofAddress(MemorySegment addr, Arena arena) {
-            MemorySegment symbol = addr.reinterpret(arena, null);
-            return (java.lang.foreign.MemorySegment __x0, int __x1, long __x2, long __x3, java.lang.foreign.MemorySegment __x4) -> {
-                try {
-                    return (int)constants$32.const$0.invokeExact(symbol, __x0, __x1, __x2, __x3, __x4);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
-        }
+    /**
+     * Allocate a segment of size {@code layout().byteSize()} using {@code allocator}
+     */
+    public static MemorySegment allocate(SegmentAllocator allocator) {
+        return allocator.allocate(layout());
     }
 
-    public static VarHandle fallocate$VH() {
-        return constants$32.const$1;
-    }
     /**
-     * Getter for field:
-     * {@snippet :
-     * int (*fallocate)(char*,int,long long,long long,struct fuse3_file_info*);
-     * }
+     * Allocate an array of size {@code elementCount} using {@code allocator}.
+     * The returned segment has size {@code elementCount * layout().byteSize()}.
      */
-    public static MemorySegment fallocate$get(MemorySegment seg) {
-        return (java.lang.foreign.MemorySegment)constants$32.const$1.get(seg);
+    public static MemorySegment allocateArray(long elementCount, SegmentAllocator allocator) {
+        return allocator.allocate(MemoryLayout.sequenceLayout(elementCount, layout()));
     }
+
     /**
-     * Setter for field:
-     * {@snippet :
-     * int (*fallocate)(char*,int,long long,long long,struct fuse3_file_info*);
-     * }
+     * Reinterprets {@code addr} using target {@code arena} and {@code cleanupAction) (if any).
+     * The returned segment has size {@code layout().byteSize()}
      */
-    public static void fallocate$set(MemorySegment seg, MemorySegment x) {
-        constants$32.const$1.set(seg, x);
-    }
-    public static MemorySegment fallocate$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemorySegment)constants$32.const$1.get(seg.asSlice(index*sizeof()));
-    }
-    public static void fallocate$set(MemorySegment seg, long index, MemorySegment x) {
-        constants$32.const$1.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static fallocate fallocate(MemorySegment segment, Arena scope) {
-        return fallocate.ofAddress(fallocate$get(segment), scope);
+    public static MemorySegment reinterpret(MemorySegment addr, Arena arena, Consumer<MemorySegment> cleanup) {
+        return reinterpret(addr, 1, arena, cleanup);
     }
-    public static long sizeof() { return $LAYOUT().byteSize(); }
-    public static MemorySegment allocate(SegmentAllocator allocator) { return allocator.allocate($LAYOUT()); }
-    public static MemorySegment allocateArray(long len, SegmentAllocator allocator) {
-        return allocator.allocate(MemoryLayout.sequenceLayout(len, $LAYOUT()));
+
+    /**
+     * Reinterprets {@code addr} using target {@code arena} and {@code cleanupAction) (if any).
+     * The returned segment has size {@code elementCount * layout().byteSize()}
+     */
+    public static MemorySegment reinterpret(MemorySegment addr, long elementCount, Arena arena, Consumer<MemorySegment> cleanup) {
+        return addr.reinterpret(layout().byteSize() * elementCount, arena, cleanup);
     }
-    public static MemorySegment ofAddress(MemorySegment addr, Arena scope) { return RuntimeHelper.asArray(addr, $LAYOUT(), 1, scope); }
 }
 
-
diff --git a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/fuse_h.java b/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/fuse_h.java
index b30494fc..493f71d7 100644
--- a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/fuse_h.java
+++ b/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/fuse_h.java
@@ -2,165 +2,496 @@
 
 package org.cryptomator.jfuse.win.extr.fuse3;
 
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
+import java.lang.invoke.*;
 import java.lang.foreign.*;
+import java.nio.ByteOrder;
+import java.util.*;
+import java.util.function.*;
+import java.util.stream.*;
+
 import static java.lang.foreign.ValueLayout.*;
-public class fuse_h  {
+import static java.lang.foreign.MemoryLayout.PathElement.*;
+
+public class fuse_h {
+
+    fuse_h() {
+        // Should not be called directly
+    }
+
+    static final Arena LIBRARY_ARENA = Arena.ofAuto();
+    static final boolean TRACE_DOWNCALLS = Boolean.getBoolean("jextract.trace.downcalls");
+
+    static void traceDowncall(String name, Object... args) {
+         String traceArgs = Arrays.stream(args)
+                       .map(Object::toString)
+                       .collect(Collectors.joining(", "));
+         System.out.printf("%s(%s)\n", name, traceArgs);
+    }
+
+    static MemorySegment findOrThrow(String symbol) {
+        return SYMBOL_LOOKUP.find(symbol)
+            .orElseThrow(() -> new UnsatisfiedLinkError("unresolved symbol: " + symbol));
+    }
+
+    static MethodHandle upcallHandle(Class<?> fi, String name, FunctionDescriptor fdesc) {
+        try {
+            return MethodHandles.lookup().findVirtual(fi, name, fdesc.toMethodType());
+        } catch (ReflectiveOperationException ex) {
+            throw new AssertionError(ex);
+        }
+    }
+
+    static MemoryLayout align(MemoryLayout layout, long align) {
+        return switch (layout) {
+            case PaddingLayout p -> p;
+            case ValueLayout v -> v.withByteAlignment(align);
+            case GroupLayout g -> {
+                MemoryLayout[] alignedMembers = g.memberLayouts().stream()
+                        .map(m -> align(m, align)).toArray(MemoryLayout[]::new);
+                yield g instanceof StructLayout ?
+                        MemoryLayout.structLayout(alignedMembers) : MemoryLayout.unionLayout(alignedMembers);
+            }
+            case SequenceLayout s -> MemoryLayout.sequenceLayout(s.elementCount(), align(s.elementLayout(), align));
+        };
+    }
+
+    static final SymbolLookup SYMBOL_LOOKUP = SymbolLookup.loaderLookup()
+            .or(Linker.nativeLinker().defaultLookup());
+
+    public static final ValueLayout.OfBoolean C_BOOL = ValueLayout.JAVA_BOOLEAN;
+    public static final ValueLayout.OfByte C_CHAR = ValueLayout.JAVA_BYTE;
+    public static final ValueLayout.OfShort C_SHORT = ValueLayout.JAVA_SHORT;
+    public static final ValueLayout.OfInt C_INT = ValueLayout.JAVA_INT;
+    public static final ValueLayout.OfLong C_LONG_LONG = ValueLayout.JAVA_LONG;
+    public static final ValueLayout.OfFloat C_FLOAT = ValueLayout.JAVA_FLOAT;
+    public static final ValueLayout.OfDouble C_DOUBLE = ValueLayout.JAVA_DOUBLE;
+    public static final AddressLayout C_POINTER = ValueLayout.ADDRESS
+            .withTargetLayout(MemoryLayout.sequenceLayout(java.lang.Long.MAX_VALUE, JAVA_BYTE));
+    public static final ValueLayout.OfInt C_LONG = ValueLayout.JAVA_INT;
+    public static final ValueLayout.OfDouble C_LONG_DOUBLE = ValueLayout.JAVA_DOUBLE;
+
+    private static class fuse3_lib_help {
+        public static final FunctionDescriptor DESC = FunctionDescriptor.ofVoid(
+            fuse_h.C_POINTER
+        );
+
+        public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(
+                    fuse_h.findOrThrow("fuse3_lib_help"),
+                    DESC);
+    }
+
+    /**
+     * Function descriptor for:
+     * {@snippet lang=c :
+     * void fuse3_lib_help(struct fuse_args *args)
+     * }
+     */
+    public static FunctionDescriptor fuse3_lib_help$descriptor() {
+        return fuse3_lib_help.DESC;
+    }
 
-    public static final OfByte C_CHAR = JAVA_BYTE;
-    public static final OfShort C_SHORT = JAVA_SHORT;
-    public static final OfInt C_INT = JAVA_INT;
-    public static final OfInt C_LONG = JAVA_INT;
-    public static final OfLong C_LONG_LONG = JAVA_LONG;
-    public static final OfFloat C_FLOAT = JAVA_FLOAT;
-    public static final OfDouble C_DOUBLE = JAVA_DOUBLE;
-    public static final AddressLayout C_POINTER = RuntimeHelper.POINTER;
-    public static MethodHandle fuse3_lib_help$MH() {
-        return RuntimeHelper.requireNonNull(constants$32.const$2,"fuse3_lib_help");
+    /**
+     * Downcall method handle for:
+     * {@snippet lang=c :
+     * void fuse3_lib_help(struct fuse_args *args)
+     * }
+     */
+    public static MethodHandle fuse3_lib_help$handle() {
+        return fuse3_lib_help.HANDLE;
     }
     /**
-     * {@snippet :
-     * void fuse3_lib_help(struct fuse_args* args);
+     * {@snippet lang=c :
+     * void fuse3_lib_help(struct fuse_args *args)
      * }
      */
     public static void fuse3_lib_help(MemorySegment args) {
-        var mh$ = fuse3_lib_help$MH();
+        var mh$ = fuse3_lib_help.HANDLE;
         try {
+            if (TRACE_DOWNCALLS) {
+                traceDowncall("fuse3_lib_help", args);
+            }
             mh$.invokeExact(args);
         } catch (Throwable ex$) {
-            throw new AssertionError("should not reach here", ex$);
+           throw new AssertionError("should not reach here", ex$);
         }
     }
-    public static MethodHandle fuse3_new$MH() {
-        return RuntimeHelper.requireNonNull(constants$32.const$4,"fuse3_new");
+
+    private static class fuse3_new {
+        public static final FunctionDescriptor DESC = FunctionDescriptor.of(
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER,
+            fuse_h.C_LONG_LONG,
+            fuse_h.C_POINTER
+        );
+
+        public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(
+                    fuse_h.findOrThrow("fuse3_new"),
+                    DESC);
+    }
+
+    /**
+     * Function descriptor for:
+     * {@snippet lang=c :
+     * struct fuse3 *fuse3_new(struct fuse_args *args, const struct fuse3_operations *ops, size_t opsize, void *data)
+     * }
+     */
+    public static FunctionDescriptor fuse3_new$descriptor() {
+        return fuse3_new.DESC;
+    }
+
+    /**
+     * Downcall method handle for:
+     * {@snippet lang=c :
+     * struct fuse3 *fuse3_new(struct fuse_args *args, const struct fuse3_operations *ops, size_t opsize, void *data)
+     * }
+     */
+    public static MethodHandle fuse3_new$handle() {
+        return fuse3_new.HANDLE;
     }
     /**
-     * {@snippet :
-     * struct fuse3* fuse3_new(struct fuse_args* args, struct fuse3_operations* ops, unsigned long long opsize, void* data);
+     * {@snippet lang=c :
+     * struct fuse3 *fuse3_new(struct fuse_args *args, const struct fuse3_operations *ops, size_t opsize, void *data)
      * }
      */
     public static MemorySegment fuse3_new(MemorySegment args, MemorySegment ops, long opsize, MemorySegment data) {
-        var mh$ = fuse3_new$MH();
+        var mh$ = fuse3_new.HANDLE;
         try {
-            return (java.lang.foreign.MemorySegment)mh$.invokeExact(args, ops, opsize, data);
+            if (TRACE_DOWNCALLS) {
+                traceDowncall("fuse3_new", args, ops, opsize, data);
+            }
+            return (MemorySegment)mh$.invokeExact(args, ops, opsize, data);
         } catch (Throwable ex$) {
-            throw new AssertionError("should not reach here", ex$);
+           throw new AssertionError("should not reach here", ex$);
         }
     }
-    public static MethodHandle fuse3_destroy$MH() {
-        return RuntimeHelper.requireNonNull(constants$32.const$5,"fuse3_destroy");
+
+    private static class fuse3_destroy {
+        public static final FunctionDescriptor DESC = FunctionDescriptor.ofVoid(
+            fuse_h.C_POINTER
+        );
+
+        public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(
+                    fuse_h.findOrThrow("fuse3_destroy"),
+                    DESC);
+    }
+
+    /**
+     * Function descriptor for:
+     * {@snippet lang=c :
+     * void fuse3_destroy(struct fuse3 *f)
+     * }
+     */
+    public static FunctionDescriptor fuse3_destroy$descriptor() {
+        return fuse3_destroy.DESC;
+    }
+
+    /**
+     * Downcall method handle for:
+     * {@snippet lang=c :
+     * void fuse3_destroy(struct fuse3 *f)
+     * }
+     */
+    public static MethodHandle fuse3_destroy$handle() {
+        return fuse3_destroy.HANDLE;
     }
     /**
-     * {@snippet :
-     * void fuse3_destroy(struct fuse3* f);
+     * {@snippet lang=c :
+     * void fuse3_destroy(struct fuse3 *f)
      * }
      */
     public static void fuse3_destroy(MemorySegment f) {
-        var mh$ = fuse3_destroy$MH();
+        var mh$ = fuse3_destroy.HANDLE;
         try {
+            if (TRACE_DOWNCALLS) {
+                traceDowncall("fuse3_destroy", f);
+            }
             mh$.invokeExact(f);
         } catch (Throwable ex$) {
-            throw new AssertionError("should not reach here", ex$);
+           throw new AssertionError("should not reach here", ex$);
         }
     }
-    public static MethodHandle fuse3_mount$MH() {
-        return RuntimeHelper.requireNonNull(constants$33.const$0,"fuse3_mount");
+
+    private static class fuse3_mount {
+        public static final FunctionDescriptor DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER
+        );
+
+        public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(
+                    fuse_h.findOrThrow("fuse3_mount"),
+                    DESC);
+    }
+
+    /**
+     * Function descriptor for:
+     * {@snippet lang=c :
+     * int fuse3_mount(struct fuse3 *f, const char *mountpoint)
+     * }
+     */
+    public static FunctionDescriptor fuse3_mount$descriptor() {
+        return fuse3_mount.DESC;
     }
+
     /**
-     * {@snippet :
-     * int fuse3_mount(struct fuse3* f, char* mountpoint);
+     * Downcall method handle for:
+     * {@snippet lang=c :
+     * int fuse3_mount(struct fuse3 *f, const char *mountpoint)
+     * }
+     */
+    public static MethodHandle fuse3_mount$handle() {
+        return fuse3_mount.HANDLE;
+    }
+    /**
+     * {@snippet lang=c :
+     * int fuse3_mount(struct fuse3 *f, const char *mountpoint)
      * }
      */
     public static int fuse3_mount(MemorySegment f, MemorySegment mountpoint) {
-        var mh$ = fuse3_mount$MH();
+        var mh$ = fuse3_mount.HANDLE;
         try {
+            if (TRACE_DOWNCALLS) {
+                traceDowncall("fuse3_mount", f, mountpoint);
+            }
             return (int)mh$.invokeExact(f, mountpoint);
         } catch (Throwable ex$) {
-            throw new AssertionError("should not reach here", ex$);
+           throw new AssertionError("should not reach here", ex$);
         }
     }
-    public static MethodHandle fuse3_unmount$MH() {
-        return RuntimeHelper.requireNonNull(constants$33.const$1,"fuse3_unmount");
+
+    private static class fuse3_unmount {
+        public static final FunctionDescriptor DESC = FunctionDescriptor.ofVoid(
+            fuse_h.C_POINTER
+        );
+
+        public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(
+                    fuse_h.findOrThrow("fuse3_unmount"),
+                    DESC);
+    }
+
+    /**
+     * Function descriptor for:
+     * {@snippet lang=c :
+     * void fuse3_unmount(struct fuse3 *f)
+     * }
+     */
+    public static FunctionDescriptor fuse3_unmount$descriptor() {
+        return fuse3_unmount.DESC;
+    }
+
+    /**
+     * Downcall method handle for:
+     * {@snippet lang=c :
+     * void fuse3_unmount(struct fuse3 *f)
+     * }
+     */
+    public static MethodHandle fuse3_unmount$handle() {
+        return fuse3_unmount.HANDLE;
     }
     /**
-     * {@snippet :
-     * void fuse3_unmount(struct fuse3* f);
+     * {@snippet lang=c :
+     * void fuse3_unmount(struct fuse3 *f)
      * }
      */
     public static void fuse3_unmount(MemorySegment f) {
-        var mh$ = fuse3_unmount$MH();
+        var mh$ = fuse3_unmount.HANDLE;
         try {
+            if (TRACE_DOWNCALLS) {
+                traceDowncall("fuse3_unmount", f);
+            }
             mh$.invokeExact(f);
         } catch (Throwable ex$) {
-            throw new AssertionError("should not reach here", ex$);
+           throw new AssertionError("should not reach here", ex$);
         }
     }
-    public static MethodHandle fuse3_loop$MH() {
-        return RuntimeHelper.requireNonNull(constants$33.const$2,"fuse3_loop");
+
+    private static class fuse3_loop {
+        public static final FunctionDescriptor DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER
+        );
+
+        public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(
+                    fuse_h.findOrThrow("fuse3_loop"),
+                    DESC);
+    }
+
+    /**
+     * Function descriptor for:
+     * {@snippet lang=c :
+     * int fuse3_loop(struct fuse3 *f)
+     * }
+     */
+    public static FunctionDescriptor fuse3_loop$descriptor() {
+        return fuse3_loop.DESC;
+    }
+
+    /**
+     * Downcall method handle for:
+     * {@snippet lang=c :
+     * int fuse3_loop(struct fuse3 *f)
+     * }
+     */
+    public static MethodHandle fuse3_loop$handle() {
+        return fuse3_loop.HANDLE;
     }
     /**
-     * {@snippet :
-     * int fuse3_loop(struct fuse3* f);
+     * {@snippet lang=c :
+     * int fuse3_loop(struct fuse3 *f)
      * }
      */
     public static int fuse3_loop(MemorySegment f) {
-        var mh$ = fuse3_loop$MH();
+        var mh$ = fuse3_loop.HANDLE;
         try {
+            if (TRACE_DOWNCALLS) {
+                traceDowncall("fuse3_loop", f);
+            }
             return (int)mh$.invokeExact(f);
         } catch (Throwable ex$) {
-            throw new AssertionError("should not reach here", ex$);
+           throw new AssertionError("should not reach here", ex$);
         }
     }
-    public static MethodHandle fuse3_loop_mt_31$MH() {
-        return RuntimeHelper.requireNonNull(constants$33.const$3,"fuse3_loop_mt_31");
+
+    private static class fuse3_loop_mt_31 {
+        public static final FunctionDescriptor DESC = FunctionDescriptor.of(
+            fuse_h.C_INT,
+            fuse_h.C_POINTER,
+            fuse_h.C_INT
+        );
+
+        public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(
+                    fuse_h.findOrThrow("fuse3_loop_mt_31"),
+                    DESC);
     }
+
     /**
-     * {@snippet :
-     * int fuse3_loop_mt_31(struct fuse3* f, int clone_fd);
+     * Function descriptor for:
+     * {@snippet lang=c :
+     * int fuse3_loop_mt_31(struct fuse3 *f, int clone_fd)
+     * }
+     */
+    public static FunctionDescriptor fuse3_loop_mt_31$descriptor() {
+        return fuse3_loop_mt_31.DESC;
+    }
+
+    /**
+     * Downcall method handle for:
+     * {@snippet lang=c :
+     * int fuse3_loop_mt_31(struct fuse3 *f, int clone_fd)
+     * }
+     */
+    public static MethodHandle fuse3_loop_mt_31$handle() {
+        return fuse3_loop_mt_31.HANDLE;
+    }
+    /**
+     * {@snippet lang=c :
+     * int fuse3_loop_mt_31(struct fuse3 *f, int clone_fd)
      * }
      */
     public static int fuse3_loop_mt_31(MemorySegment f, int clone_fd) {
-        var mh$ = fuse3_loop_mt_31$MH();
+        var mh$ = fuse3_loop_mt_31.HANDLE;
         try {
+            if (TRACE_DOWNCALLS) {
+                traceDowncall("fuse3_loop_mt_31", f, clone_fd);
+            }
             return (int)mh$.invokeExact(f, clone_fd);
         } catch (Throwable ex$) {
-            throw new AssertionError("should not reach here", ex$);
+           throw new AssertionError("should not reach here", ex$);
         }
     }
-    public static MethodHandle fuse3_exit$MH() {
-        return RuntimeHelper.requireNonNull(constants$33.const$4,"fuse3_exit");
+
+    private static class fuse3_exit {
+        public static final FunctionDescriptor DESC = FunctionDescriptor.ofVoid(
+            fuse_h.C_POINTER
+        );
+
+        public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(
+                    fuse_h.findOrThrow("fuse3_exit"),
+                    DESC);
+    }
+
+    /**
+     * Function descriptor for:
+     * {@snippet lang=c :
+     * void fuse3_exit(struct fuse3 *f)
+     * }
+     */
+    public static FunctionDescriptor fuse3_exit$descriptor() {
+        return fuse3_exit.DESC;
     }
+
     /**
-     * {@snippet :
-     * void fuse3_exit(struct fuse3* f);
+     * Downcall method handle for:
+     * {@snippet lang=c :
+     * void fuse3_exit(struct fuse3 *f)
+     * }
+     */
+    public static MethodHandle fuse3_exit$handle() {
+        return fuse3_exit.HANDLE;
+    }
+    /**
+     * {@snippet lang=c :
+     * void fuse3_exit(struct fuse3 *f)
      * }
      */
     public static void fuse3_exit(MemorySegment f) {
-        var mh$ = fuse3_exit$MH();
+        var mh$ = fuse3_exit.HANDLE;
         try {
+            if (TRACE_DOWNCALLS) {
+                traceDowncall("fuse3_exit", f);
+            }
             mh$.invokeExact(f);
         } catch (Throwable ex$) {
-            throw new AssertionError("should not reach here", ex$);
+           throw new AssertionError("should not reach here", ex$);
         }
     }
-    public static MethodHandle fuse3_get_session$MH() {
-        return RuntimeHelper.requireNonNull(constants$33.const$6,"fuse3_get_session");
+
+    private static class fuse3_get_session {
+        public static final FunctionDescriptor DESC = FunctionDescriptor.of(
+            fuse_h.C_POINTER,
+            fuse_h.C_POINTER
+        );
+
+        public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(
+                    fuse_h.findOrThrow("fuse3_get_session"),
+                    DESC);
     }
+
     /**
-     * {@snippet :
-     * struct fuse3_session* fuse3_get_session(struct fuse3* f);
+     * Function descriptor for:
+     * {@snippet lang=c :
+     * struct fuse3_session *fuse3_get_session(struct fuse3 *f)
+     * }
+     */
+    public static FunctionDescriptor fuse3_get_session$descriptor() {
+        return fuse3_get_session.DESC;
+    }
+
+    /**
+     * Downcall method handle for:
+     * {@snippet lang=c :
+     * struct fuse3_session *fuse3_get_session(struct fuse3 *f)
+     * }
+     */
+    public static MethodHandle fuse3_get_session$handle() {
+        return fuse3_get_session.HANDLE;
+    }
+    /**
+     * {@snippet lang=c :
+     * struct fuse3_session *fuse3_get_session(struct fuse3 *f)
      * }
      */
     public static MemorySegment fuse3_get_session(MemorySegment f) {
-        var mh$ = fuse3_get_session$MH();
+        var mh$ = fuse3_get_session.HANDLE;
         try {
-            return (java.lang.foreign.MemorySegment)mh$.invokeExact(f);
+            if (TRACE_DOWNCALLS) {
+                traceDowncall("fuse3_get_session", f);
+            }
+            return (MemorySegment)mh$.invokeExact(f);
         } catch (Throwable ex$) {
-            throw new AssertionError("should not reach here", ex$);
+           throw new AssertionError("should not reach here", ex$);
         }
     }
 }
 
-
diff --git a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/fuse_stat.java b/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/fuse_stat.java
index 8783e45c..e3ed858e 100644
--- a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/fuse_stat.java
+++ b/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/fuse_stat.java
@@ -2,324 +2,728 @@
 
 package org.cryptomator.jfuse.win.extr.fuse3;
 
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
+import java.lang.invoke.*;
 import java.lang.foreign.*;
+import java.nio.ByteOrder;
+import java.util.*;
+import java.util.function.*;
+import java.util.stream.*;
+
 import static java.lang.foreign.ValueLayout.*;
+import static java.lang.foreign.MemoryLayout.PathElement.*;
+
 /**
- * {@snippet :
+ * {@snippet lang=c :
  * struct fuse_stat {
- *     unsigned int st_dev;
- *     unsigned long long st_ino;
- *     unsigned int st_mode;
- *     unsigned short st_nlink;
- *     unsigned int st_uid;
- *     unsigned int st_gid;
- *     unsigned int st_rdev;
- *     long long st_size;
+ *     fuse_dev_t st_dev;
+ *     fuse_ino_t st_ino;
+ *     fuse_mode_t st_mode;
+ *     fuse_nlink_t st_nlink;
+ *     fuse_uid_t st_uid;
+ *     fuse_gid_t st_gid;
+ *     fuse_dev_t st_rdev;
+ *     fuse_off_t st_size;
  *     struct fuse_timespec st_atim;
  *     struct fuse_timespec st_mtim;
  *     struct fuse_timespec st_ctim;
- *     int st_blksize;
- *     long long st_blocks;
+ *     fuse_blksize_t st_blksize;
+ *     fuse_blkcnt_t st_blocks;
  *     struct fuse_timespec st_birthtim;
- * };
+ * }
  * }
  */
 public class fuse_stat {
 
-    public static MemoryLayout $LAYOUT() {
-        return constants$0.const$3;
+    fuse_stat() {
+        // Should not be called directly
     }
-    public static VarHandle st_dev$VH() {
-        return constants$0.const$4;
+
+    private static final GroupLayout $LAYOUT = MemoryLayout.structLayout(
+        fuse_h.C_INT.withName("st_dev"),
+        MemoryLayout.paddingLayout(4),
+        fuse_h.C_LONG_LONG.withName("st_ino"),
+        fuse_h.C_INT.withName("st_mode"),
+        fuse_h.C_SHORT.withName("st_nlink"),
+        MemoryLayout.paddingLayout(2),
+        fuse_h.C_INT.withName("st_uid"),
+        fuse_h.C_INT.withName("st_gid"),
+        fuse_h.C_INT.withName("st_rdev"),
+        MemoryLayout.paddingLayout(4),
+        fuse_h.C_LONG_LONG.withName("st_size"),
+        fuse_timespec.layout().withName("st_atim"),
+        fuse_timespec.layout().withName("st_mtim"),
+        fuse_timespec.layout().withName("st_ctim"),
+        fuse_h.C_INT.withName("st_blksize"),
+        MemoryLayout.paddingLayout(4),
+        fuse_h.C_LONG_LONG.withName("st_blocks"),
+        fuse_timespec.layout().withName("st_birthtim")
+    ).withName("fuse_stat");
+
+    /**
+     * The layout of this struct
+     */
+    public static final GroupLayout layout() {
+        return $LAYOUT;
     }
+
+    private static final OfInt st_dev$LAYOUT = (OfInt)$LAYOUT.select(groupElement("st_dev"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * fuse_dev_t st_dev
+     * }
+     */
+    public static final OfInt st_dev$layout() {
+        return st_dev$LAYOUT;
+    }
+
+    private static final long st_dev$OFFSET = 0;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * fuse_dev_t st_dev
+     * }
+     */
+    public static final long st_dev$offset() {
+        return st_dev$OFFSET;
+    }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned int st_dev;
+     * {@snippet lang=c :
+     * fuse_dev_t st_dev
      * }
      */
-    public static int st_dev$get(MemorySegment seg) {
-        return (int)constants$0.const$4.get(seg);
+    public static int st_dev(MemorySegment struct) {
+        return struct.get(st_dev$LAYOUT, st_dev$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned int st_dev;
+     * {@snippet lang=c :
+     * fuse_dev_t st_dev
      * }
      */
-    public static void st_dev$set(MemorySegment seg, int x) {
-        constants$0.const$4.set(seg, x);
-    }
-    public static int st_dev$get(MemorySegment seg, long index) {
-        return (int)constants$0.const$4.get(seg.asSlice(index*sizeof()));
+    public static void st_dev(MemorySegment struct, int fieldValue) {
+        struct.set(st_dev$LAYOUT, st_dev$OFFSET, fieldValue);
     }
-    public static void st_dev$set(MemorySegment seg, long index, int x) {
-        constants$0.const$4.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfLong st_ino$LAYOUT = (OfLong)$LAYOUT.select(groupElement("st_ino"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * fuse_ino_t st_ino
+     * }
+     */
+    public static final OfLong st_ino$layout() {
+        return st_ino$LAYOUT;
     }
-    public static VarHandle st_ino$VH() {
-        return constants$0.const$5;
+
+    private static final long st_ino$OFFSET = 8;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * fuse_ino_t st_ino
+     * }
+     */
+    public static final long st_ino$offset() {
+        return st_ino$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned long long st_ino;
+     * {@snippet lang=c :
+     * fuse_ino_t st_ino
      * }
      */
-    public static long st_ino$get(MemorySegment seg) {
-        return (long)constants$0.const$5.get(seg);
+    public static long st_ino(MemorySegment struct) {
+        return struct.get(st_ino$LAYOUT, st_ino$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned long long st_ino;
+     * {@snippet lang=c :
+     * fuse_ino_t st_ino
      * }
      */
-    public static void st_ino$set(MemorySegment seg, long x) {
-        constants$0.const$5.set(seg, x);
-    }
-    public static long st_ino$get(MemorySegment seg, long index) {
-        return (long)constants$0.const$5.get(seg.asSlice(index*sizeof()));
+    public static void st_ino(MemorySegment struct, long fieldValue) {
+        struct.set(st_ino$LAYOUT, st_ino$OFFSET, fieldValue);
     }
-    public static void st_ino$set(MemorySegment seg, long index, long x) {
-        constants$0.const$5.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt st_mode$LAYOUT = (OfInt)$LAYOUT.select(groupElement("st_mode"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * fuse_mode_t st_mode
+     * }
+     */
+    public static final OfInt st_mode$layout() {
+        return st_mode$LAYOUT;
     }
-    public static VarHandle st_mode$VH() {
-        return constants$1.const$0;
+
+    private static final long st_mode$OFFSET = 16;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * fuse_mode_t st_mode
+     * }
+     */
+    public static final long st_mode$offset() {
+        return st_mode$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned int st_mode;
+     * {@snippet lang=c :
+     * fuse_mode_t st_mode
      * }
      */
-    public static int st_mode$get(MemorySegment seg) {
-        return (int)constants$1.const$0.get(seg);
+    public static int st_mode(MemorySegment struct) {
+        return struct.get(st_mode$LAYOUT, st_mode$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned int st_mode;
+     * {@snippet lang=c :
+     * fuse_mode_t st_mode
      * }
      */
-    public static void st_mode$set(MemorySegment seg, int x) {
-        constants$1.const$0.set(seg, x);
+    public static void st_mode(MemorySegment struct, int fieldValue) {
+        struct.set(st_mode$LAYOUT, st_mode$OFFSET, fieldValue);
     }
-    public static int st_mode$get(MemorySegment seg, long index) {
-        return (int)constants$1.const$0.get(seg.asSlice(index*sizeof()));
-    }
-    public static void st_mode$set(MemorySegment seg, long index, int x) {
-        constants$1.const$0.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfShort st_nlink$LAYOUT = (OfShort)$LAYOUT.select(groupElement("st_nlink"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * fuse_nlink_t st_nlink
+     * }
+     */
+    public static final OfShort st_nlink$layout() {
+        return st_nlink$LAYOUT;
     }
-    public static VarHandle st_nlink$VH() {
-        return constants$1.const$1;
+
+    private static final long st_nlink$OFFSET = 20;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * fuse_nlink_t st_nlink
+     * }
+     */
+    public static final long st_nlink$offset() {
+        return st_nlink$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned short st_nlink;
+     * {@snippet lang=c :
+     * fuse_nlink_t st_nlink
      * }
      */
-    public static short st_nlink$get(MemorySegment seg) {
-        return (short)constants$1.const$1.get(seg);
+    public static short st_nlink(MemorySegment struct) {
+        return struct.get(st_nlink$LAYOUT, st_nlink$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned short st_nlink;
+     * {@snippet lang=c :
+     * fuse_nlink_t st_nlink
      * }
      */
-    public static void st_nlink$set(MemorySegment seg, short x) {
-        constants$1.const$1.set(seg, x);
+    public static void st_nlink(MemorySegment struct, short fieldValue) {
+        struct.set(st_nlink$LAYOUT, st_nlink$OFFSET, fieldValue);
     }
-    public static short st_nlink$get(MemorySegment seg, long index) {
-        return (short)constants$1.const$1.get(seg.asSlice(index*sizeof()));
-    }
-    public static void st_nlink$set(MemorySegment seg, long index, short x) {
-        constants$1.const$1.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt st_uid$LAYOUT = (OfInt)$LAYOUT.select(groupElement("st_uid"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * fuse_uid_t st_uid
+     * }
+     */
+    public static final OfInt st_uid$layout() {
+        return st_uid$LAYOUT;
     }
-    public static VarHandle st_uid$VH() {
-        return constants$1.const$2;
+
+    private static final long st_uid$OFFSET = 24;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * fuse_uid_t st_uid
+     * }
+     */
+    public static final long st_uid$offset() {
+        return st_uid$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned int st_uid;
+     * {@snippet lang=c :
+     * fuse_uid_t st_uid
      * }
      */
-    public static int st_uid$get(MemorySegment seg) {
-        return (int)constants$1.const$2.get(seg);
+    public static int st_uid(MemorySegment struct) {
+        return struct.get(st_uid$LAYOUT, st_uid$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned int st_uid;
+     * {@snippet lang=c :
+     * fuse_uid_t st_uid
      * }
      */
-    public static void st_uid$set(MemorySegment seg, int x) {
-        constants$1.const$2.set(seg, x);
-    }
-    public static int st_uid$get(MemorySegment seg, long index) {
-        return (int)constants$1.const$2.get(seg.asSlice(index*sizeof()));
+    public static void st_uid(MemorySegment struct, int fieldValue) {
+        struct.set(st_uid$LAYOUT, st_uid$OFFSET, fieldValue);
     }
-    public static void st_uid$set(MemorySegment seg, long index, int x) {
-        constants$1.const$2.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfInt st_gid$LAYOUT = (OfInt)$LAYOUT.select(groupElement("st_gid"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * fuse_gid_t st_gid
+     * }
+     */
+    public static final OfInt st_gid$layout() {
+        return st_gid$LAYOUT;
     }
-    public static VarHandle st_gid$VH() {
-        return constants$1.const$3;
+
+    private static final long st_gid$OFFSET = 28;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * fuse_gid_t st_gid
+     * }
+     */
+    public static final long st_gid$offset() {
+        return st_gid$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned int st_gid;
+     * {@snippet lang=c :
+     * fuse_gid_t st_gid
      * }
      */
-    public static int st_gid$get(MemorySegment seg) {
-        return (int)constants$1.const$3.get(seg);
+    public static int st_gid(MemorySegment struct) {
+        return struct.get(st_gid$LAYOUT, st_gid$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned int st_gid;
+     * {@snippet lang=c :
+     * fuse_gid_t st_gid
      * }
      */
-    public static void st_gid$set(MemorySegment seg, int x) {
-        constants$1.const$3.set(seg, x);
+    public static void st_gid(MemorySegment struct, int fieldValue) {
+        struct.set(st_gid$LAYOUT, st_gid$OFFSET, fieldValue);
     }
-    public static int st_gid$get(MemorySegment seg, long index) {
-        return (int)constants$1.const$3.get(seg.asSlice(index*sizeof()));
+
+    private static final OfInt st_rdev$LAYOUT = (OfInt)$LAYOUT.select(groupElement("st_rdev"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * fuse_dev_t st_rdev
+     * }
+     */
+    public static final OfInt st_rdev$layout() {
+        return st_rdev$LAYOUT;
     }
-    public static void st_gid$set(MemorySegment seg, long index, int x) {
-        constants$1.const$3.set(seg.asSlice(index*sizeof()), x);
+
+    private static final long st_rdev$OFFSET = 32;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * fuse_dev_t st_rdev
+     * }
+     */
+    public static final long st_rdev$offset() {
+        return st_rdev$OFFSET;
+    }
+
+    /**
+     * Getter for field:
+     * {@snippet lang=c :
+     * fuse_dev_t st_rdev
+     * }
+     */
+    public static int st_rdev(MemorySegment struct) {
+        return struct.get(st_rdev$LAYOUT, st_rdev$OFFSET);
+    }
+
+    /**
+     * Setter for field:
+     * {@snippet lang=c :
+     * fuse_dev_t st_rdev
+     * }
+     */
+    public static void st_rdev(MemorySegment struct, int fieldValue) {
+        struct.set(st_rdev$LAYOUT, st_rdev$OFFSET, fieldValue);
     }
-    public static VarHandle st_rdev$VH() {
-        return constants$1.const$4;
+
+    private static final OfLong st_size$LAYOUT = (OfLong)$LAYOUT.select(groupElement("st_size"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * fuse_off_t st_size
+     * }
+     */
+    public static final OfLong st_size$layout() {
+        return st_size$LAYOUT;
     }
+
+    private static final long st_size$OFFSET = 40;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * fuse_off_t st_size
+     * }
+     */
+    public static final long st_size$offset() {
+        return st_size$OFFSET;
+    }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned int st_rdev;
+     * {@snippet lang=c :
+     * fuse_off_t st_size
      * }
      */
-    public static int st_rdev$get(MemorySegment seg) {
-        return (int)constants$1.const$4.get(seg);
+    public static long st_size(MemorySegment struct) {
+        return struct.get(st_size$LAYOUT, st_size$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned int st_rdev;
+     * {@snippet lang=c :
+     * fuse_off_t st_size
      * }
      */
-    public static void st_rdev$set(MemorySegment seg, int x) {
-        constants$1.const$4.set(seg, x);
+    public static void st_size(MemorySegment struct, long fieldValue) {
+        struct.set(st_size$LAYOUT, st_size$OFFSET, fieldValue);
     }
-    public static int st_rdev$get(MemorySegment seg, long index) {
-        return (int)constants$1.const$4.get(seg.asSlice(index*sizeof()));
+
+    private static final GroupLayout st_atim$LAYOUT = (GroupLayout)$LAYOUT.select(groupElement("st_atim"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * struct fuse_timespec st_atim
+     * }
+     */
+    public static final GroupLayout st_atim$layout() {
+        return st_atim$LAYOUT;
     }
-    public static void st_rdev$set(MemorySegment seg, long index, int x) {
-        constants$1.const$4.set(seg.asSlice(index*sizeof()), x);
+
+    private static final long st_atim$OFFSET = 48;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * struct fuse_timespec st_atim
+     * }
+     */
+    public static final long st_atim$offset() {
+        return st_atim$OFFSET;
     }
-    public static VarHandle st_size$VH() {
-        return constants$1.const$5;
+
+    /**
+     * Getter for field:
+     * {@snippet lang=c :
+     * struct fuse_timespec st_atim
+     * }
+     */
+    public static MemorySegment st_atim(MemorySegment struct) {
+        return struct.asSlice(st_atim$OFFSET, st_atim$LAYOUT.byteSize());
     }
+
+    /**
+     * Setter for field:
+     * {@snippet lang=c :
+     * struct fuse_timespec st_atim
+     * }
+     */
+    public static void st_atim(MemorySegment struct, MemorySegment fieldValue) {
+        MemorySegment.copy(fieldValue, 0L, struct, st_atim$OFFSET, st_atim$LAYOUT.byteSize());
+    }
+
+    private static final GroupLayout st_mtim$LAYOUT = (GroupLayout)$LAYOUT.select(groupElement("st_mtim"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * struct fuse_timespec st_mtim
+     * }
+     */
+    public static final GroupLayout st_mtim$layout() {
+        return st_mtim$LAYOUT;
+    }
+
+    private static final long st_mtim$OFFSET = 64;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * struct fuse_timespec st_mtim
+     * }
+     */
+    public static final long st_mtim$offset() {
+        return st_mtim$OFFSET;
+    }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * long long st_size;
+     * {@snippet lang=c :
+     * struct fuse_timespec st_mtim
      * }
      */
-    public static long st_size$get(MemorySegment seg) {
-        return (long)constants$1.const$5.get(seg);
+    public static MemorySegment st_mtim(MemorySegment struct) {
+        return struct.asSlice(st_mtim$OFFSET, st_mtim$LAYOUT.byteSize());
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * long long st_size;
+     * {@snippet lang=c :
+     * struct fuse_timespec st_mtim
      * }
      */
-    public static void st_size$set(MemorySegment seg, long x) {
-        constants$1.const$5.set(seg, x);
+    public static void st_mtim(MemorySegment struct, MemorySegment fieldValue) {
+        MemorySegment.copy(fieldValue, 0L, struct, st_mtim$OFFSET, st_mtim$LAYOUT.byteSize());
     }
-    public static long st_size$get(MemorySegment seg, long index) {
-        return (long)constants$1.const$5.get(seg.asSlice(index*sizeof()));
+
+    private static final GroupLayout st_ctim$LAYOUT = (GroupLayout)$LAYOUT.select(groupElement("st_ctim"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * struct fuse_timespec st_ctim
+     * }
+     */
+    public static final GroupLayout st_ctim$layout() {
+        return st_ctim$LAYOUT;
     }
-    public static void st_size$set(MemorySegment seg, long index, long x) {
-        constants$1.const$5.set(seg.asSlice(index*sizeof()), x);
+
+    private static final long st_ctim$OFFSET = 80;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * struct fuse_timespec st_ctim
+     * }
+     */
+    public static final long st_ctim$offset() {
+        return st_ctim$OFFSET;
     }
-    public static MemorySegment st_atim$slice(MemorySegment seg) {
-        return seg.asSlice(48, 16);
+
+    /**
+     * Getter for field:
+     * {@snippet lang=c :
+     * struct fuse_timespec st_ctim
+     * }
+     */
+    public static MemorySegment st_ctim(MemorySegment struct) {
+        return struct.asSlice(st_ctim$OFFSET, st_ctim$LAYOUT.byteSize());
     }
-    public static MemorySegment st_mtim$slice(MemorySegment seg) {
-        return seg.asSlice(64, 16);
+
+    /**
+     * Setter for field:
+     * {@snippet lang=c :
+     * struct fuse_timespec st_ctim
+     * }
+     */
+    public static void st_ctim(MemorySegment struct, MemorySegment fieldValue) {
+        MemorySegment.copy(fieldValue, 0L, struct, st_ctim$OFFSET, st_ctim$LAYOUT.byteSize());
     }
-    public static MemorySegment st_ctim$slice(MemorySegment seg) {
-        return seg.asSlice(80, 16);
+
+    private static final OfInt st_blksize$LAYOUT = (OfInt)$LAYOUT.select(groupElement("st_blksize"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * fuse_blksize_t st_blksize
+     * }
+     */
+    public static final OfInt st_blksize$layout() {
+        return st_blksize$LAYOUT;
     }
-    public static VarHandle st_blksize$VH() {
-        return constants$2.const$0;
+
+    private static final long st_blksize$OFFSET = 96;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * fuse_blksize_t st_blksize
+     * }
+     */
+    public static final long st_blksize$offset() {
+        return st_blksize$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * int st_blksize;
+     * {@snippet lang=c :
+     * fuse_blksize_t st_blksize
      * }
      */
-    public static int st_blksize$get(MemorySegment seg) {
-        return (int)constants$2.const$0.get(seg);
+    public static int st_blksize(MemorySegment struct) {
+        return struct.get(st_blksize$LAYOUT, st_blksize$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * int st_blksize;
+     * {@snippet lang=c :
+     * fuse_blksize_t st_blksize
      * }
      */
-    public static void st_blksize$set(MemorySegment seg, int x) {
-        constants$2.const$0.set(seg, x);
+    public static void st_blksize(MemorySegment struct, int fieldValue) {
+        struct.set(st_blksize$LAYOUT, st_blksize$OFFSET, fieldValue);
     }
-    public static int st_blksize$get(MemorySegment seg, long index) {
-        return (int)constants$2.const$0.get(seg.asSlice(index*sizeof()));
+
+    private static final OfLong st_blocks$LAYOUT = (OfLong)$LAYOUT.select(groupElement("st_blocks"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * fuse_blkcnt_t st_blocks
+     * }
+     */
+    public static final OfLong st_blocks$layout() {
+        return st_blocks$LAYOUT;
     }
-    public static void st_blksize$set(MemorySegment seg, long index, int x) {
-        constants$2.const$0.set(seg.asSlice(index*sizeof()), x);
+
+    private static final long st_blocks$OFFSET = 104;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * fuse_blkcnt_t st_blocks
+     * }
+     */
+    public static final long st_blocks$offset() {
+        return st_blocks$OFFSET;
     }
-    public static VarHandle st_blocks$VH() {
-        return constants$2.const$1;
+
+    /**
+     * Getter for field:
+     * {@snippet lang=c :
+     * fuse_blkcnt_t st_blocks
+     * }
+     */
+    public static long st_blocks(MemorySegment struct) {
+        return struct.get(st_blocks$LAYOUT, st_blocks$OFFSET);
     }
+
+    /**
+     * Setter for field:
+     * {@snippet lang=c :
+     * fuse_blkcnt_t st_blocks
+     * }
+     */
+    public static void st_blocks(MemorySegment struct, long fieldValue) {
+        struct.set(st_blocks$LAYOUT, st_blocks$OFFSET, fieldValue);
+    }
+
+    private static final GroupLayout st_birthtim$LAYOUT = (GroupLayout)$LAYOUT.select(groupElement("st_birthtim"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * struct fuse_timespec st_birthtim
+     * }
+     */
+    public static final GroupLayout st_birthtim$layout() {
+        return st_birthtim$LAYOUT;
+    }
+
+    private static final long st_birthtim$OFFSET = 112;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * struct fuse_timespec st_birthtim
+     * }
+     */
+    public static final long st_birthtim$offset() {
+        return st_birthtim$OFFSET;
+    }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * long long st_blocks;
+     * {@snippet lang=c :
+     * struct fuse_timespec st_birthtim
      * }
      */
-    public static long st_blocks$get(MemorySegment seg) {
-        return (long)constants$2.const$1.get(seg);
+    public static MemorySegment st_birthtim(MemorySegment struct) {
+        return struct.asSlice(st_birthtim$OFFSET, st_birthtim$LAYOUT.byteSize());
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * long long st_blocks;
+     * {@snippet lang=c :
+     * struct fuse_timespec st_birthtim
      * }
      */
-    public static void st_blocks$set(MemorySegment seg, long x) {
-        constants$2.const$1.set(seg, x);
+    public static void st_birthtim(MemorySegment struct, MemorySegment fieldValue) {
+        MemorySegment.copy(fieldValue, 0L, struct, st_birthtim$OFFSET, st_birthtim$LAYOUT.byteSize());
     }
-    public static long st_blocks$get(MemorySegment seg, long index) {
-        return (long)constants$2.const$1.get(seg.asSlice(index*sizeof()));
+
+    /**
+     * Obtains a slice of {@code arrayParam} which selects the array element at {@code index}.
+     * The returned segment has address {@code arrayParam.address() + index * layout().byteSize()}
+     */
+    public static MemorySegment asSlice(MemorySegment array, long index) {
+        return array.asSlice(layout().byteSize() * index);
+    }
+
+    /**
+     * The size (in bytes) of this struct
+     */
+    public static long sizeof() { return layout().byteSize(); }
+
+    /**
+     * Allocate a segment of size {@code layout().byteSize()} using {@code allocator}
+     */
+    public static MemorySegment allocate(SegmentAllocator allocator) {
+        return allocator.allocate(layout());
     }
-    public static void st_blocks$set(MemorySegment seg, long index, long x) {
-        constants$2.const$1.set(seg.asSlice(index*sizeof()), x);
+
+    /**
+     * Allocate an array of size {@code elementCount} using {@code allocator}.
+     * The returned segment has size {@code elementCount * layout().byteSize()}.
+     */
+    public static MemorySegment allocateArray(long elementCount, SegmentAllocator allocator) {
+        return allocator.allocate(MemoryLayout.sequenceLayout(elementCount, layout()));
     }
-    public static MemorySegment st_birthtim$slice(MemorySegment seg) {
-        return seg.asSlice(112, 16);
+
+    /**
+     * Reinterprets {@code addr} using target {@code arena} and {@code cleanupAction) (if any).
+     * The returned segment has size {@code layout().byteSize()}
+     */
+    public static MemorySegment reinterpret(MemorySegment addr, Arena arena, Consumer<MemorySegment> cleanup) {
+        return reinterpret(addr, 1, arena, cleanup);
     }
-    public static long sizeof() { return $LAYOUT().byteSize(); }
-    public static MemorySegment allocate(SegmentAllocator allocator) { return allocator.allocate($LAYOUT()); }
-    public static MemorySegment allocateArray(long len, SegmentAllocator allocator) {
-        return allocator.allocate(MemoryLayout.sequenceLayout(len, $LAYOUT()));
+
+    /**
+     * Reinterprets {@code addr} using target {@code arena} and {@code cleanupAction) (if any).
+     * The returned segment has size {@code elementCount * layout().byteSize()}
+     */
+    public static MemorySegment reinterpret(MemorySegment addr, long elementCount, Arena arena, Consumer<MemorySegment> cleanup) {
+        return addr.reinterpret(layout().byteSize() * elementCount, arena, cleanup);
     }
-    public static MemorySegment ofAddress(MemorySegment addr, Arena scope) { return RuntimeHelper.asArray(addr, $LAYOUT(), 1, scope); }
 }
 
-
diff --git a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/fuse_statvfs.java b/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/fuse_statvfs.java
index f000f68b..2b07d40b 100644
--- a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/fuse_statvfs.java
+++ b/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/fuse_statvfs.java
@@ -2,336 +2,586 @@
 
 package org.cryptomator.jfuse.win.extr.fuse3;
 
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
+import java.lang.invoke.*;
 import java.lang.foreign.*;
+import java.nio.ByteOrder;
+import java.util.*;
+import java.util.function.*;
+import java.util.stream.*;
+
 import static java.lang.foreign.ValueLayout.*;
+import static java.lang.foreign.MemoryLayout.PathElement.*;
+
 /**
- * {@snippet :
+ * {@snippet lang=c :
  * struct fuse_statvfs {
- *     unsigned long long f_bsize;
- *     unsigned long long f_frsize;
- *     unsigned long long f_blocks;
- *     unsigned long long f_bfree;
- *     unsigned long long f_bavail;
- *     unsigned long long f_files;
- *     unsigned long long f_ffree;
- *     unsigned long long f_favail;
- *     unsigned long long f_fsid;
- *     unsigned long long f_flag;
- *     unsigned long long f_namemax;
- * };
+ *     uint64_t f_bsize;
+ *     uint64_t f_frsize;
+ *     fuse_fsblkcnt_t f_blocks;
+ *     fuse_fsblkcnt_t f_bfree;
+ *     fuse_fsblkcnt_t f_bavail;
+ *     fuse_fsfilcnt_t f_files;
+ *     fuse_fsfilcnt_t f_ffree;
+ *     fuse_fsfilcnt_t f_favail;
+ *     uint64_t f_fsid;
+ *     uint64_t f_flag;
+ *     uint64_t f_namemax;
+ * }
  * }
  */
 public class fuse_statvfs {
 
-    public static MemoryLayout $LAYOUT() {
-        return constants$2.const$2;
+    fuse_statvfs() {
+        // Should not be called directly
+    }
+
+    private static final GroupLayout $LAYOUT = MemoryLayout.structLayout(
+        fuse_h.C_LONG_LONG.withName("f_bsize"),
+        fuse_h.C_LONG_LONG.withName("f_frsize"),
+        fuse_h.C_LONG_LONG.withName("f_blocks"),
+        fuse_h.C_LONG_LONG.withName("f_bfree"),
+        fuse_h.C_LONG_LONG.withName("f_bavail"),
+        fuse_h.C_LONG_LONG.withName("f_files"),
+        fuse_h.C_LONG_LONG.withName("f_ffree"),
+        fuse_h.C_LONG_LONG.withName("f_favail"),
+        fuse_h.C_LONG_LONG.withName("f_fsid"),
+        fuse_h.C_LONG_LONG.withName("f_flag"),
+        fuse_h.C_LONG_LONG.withName("f_namemax")
+    ).withName("fuse_statvfs");
+
+    /**
+     * The layout of this struct
+     */
+    public static final GroupLayout layout() {
+        return $LAYOUT;
+    }
+
+    private static final OfLong f_bsize$LAYOUT = (OfLong)$LAYOUT.select(groupElement("f_bsize"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * uint64_t f_bsize
+     * }
+     */
+    public static final OfLong f_bsize$layout() {
+        return f_bsize$LAYOUT;
     }
-    public static VarHandle f_bsize$VH() {
-        return constants$2.const$3;
+
+    private static final long f_bsize$OFFSET = 0;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * uint64_t f_bsize
+     * }
+     */
+    public static final long f_bsize$offset() {
+        return f_bsize$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned long long f_bsize;
+     * {@snippet lang=c :
+     * uint64_t f_bsize
      * }
      */
-    public static long f_bsize$get(MemorySegment seg) {
-        return (long)constants$2.const$3.get(seg);
+    public static long f_bsize(MemorySegment struct) {
+        return struct.get(f_bsize$LAYOUT, f_bsize$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned long long f_bsize;
+     * {@snippet lang=c :
+     * uint64_t f_bsize
      * }
      */
-    public static void f_bsize$set(MemorySegment seg, long x) {
-        constants$2.const$3.set(seg, x);
-    }
-    public static long f_bsize$get(MemorySegment seg, long index) {
-        return (long)constants$2.const$3.get(seg.asSlice(index*sizeof()));
+    public static void f_bsize(MemorySegment struct, long fieldValue) {
+        struct.set(f_bsize$LAYOUT, f_bsize$OFFSET, fieldValue);
     }
-    public static void f_bsize$set(MemorySegment seg, long index, long x) {
-        constants$2.const$3.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfLong f_frsize$LAYOUT = (OfLong)$LAYOUT.select(groupElement("f_frsize"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * uint64_t f_frsize
+     * }
+     */
+    public static final OfLong f_frsize$layout() {
+        return f_frsize$LAYOUT;
     }
-    public static VarHandle f_frsize$VH() {
-        return constants$2.const$4;
+
+    private static final long f_frsize$OFFSET = 8;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * uint64_t f_frsize
+     * }
+     */
+    public static final long f_frsize$offset() {
+        return f_frsize$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned long long f_frsize;
+     * {@snippet lang=c :
+     * uint64_t f_frsize
      * }
      */
-    public static long f_frsize$get(MemorySegment seg) {
-        return (long)constants$2.const$4.get(seg);
+    public static long f_frsize(MemorySegment struct) {
+        return struct.get(f_frsize$LAYOUT, f_frsize$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned long long f_frsize;
+     * {@snippet lang=c :
+     * uint64_t f_frsize
      * }
      */
-    public static void f_frsize$set(MemorySegment seg, long x) {
-        constants$2.const$4.set(seg, x);
+    public static void f_frsize(MemorySegment struct, long fieldValue) {
+        struct.set(f_frsize$LAYOUT, f_frsize$OFFSET, fieldValue);
     }
-    public static long f_frsize$get(MemorySegment seg, long index) {
-        return (long)constants$2.const$4.get(seg.asSlice(index*sizeof()));
-    }
-    public static void f_frsize$set(MemorySegment seg, long index, long x) {
-        constants$2.const$4.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfLong f_blocks$LAYOUT = (OfLong)$LAYOUT.select(groupElement("f_blocks"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * fuse_fsblkcnt_t f_blocks
+     * }
+     */
+    public static final OfLong f_blocks$layout() {
+        return f_blocks$LAYOUT;
     }
-    public static VarHandle f_blocks$VH() {
-        return constants$2.const$5;
+
+    private static final long f_blocks$OFFSET = 16;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * fuse_fsblkcnt_t f_blocks
+     * }
+     */
+    public static final long f_blocks$offset() {
+        return f_blocks$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned long long f_blocks;
+     * {@snippet lang=c :
+     * fuse_fsblkcnt_t f_blocks
      * }
      */
-    public static long f_blocks$get(MemorySegment seg) {
-        return (long)constants$2.const$5.get(seg);
+    public static long f_blocks(MemorySegment struct) {
+        return struct.get(f_blocks$LAYOUT, f_blocks$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned long long f_blocks;
+     * {@snippet lang=c :
+     * fuse_fsblkcnt_t f_blocks
      * }
      */
-    public static void f_blocks$set(MemorySegment seg, long x) {
-        constants$2.const$5.set(seg, x);
-    }
-    public static long f_blocks$get(MemorySegment seg, long index) {
-        return (long)constants$2.const$5.get(seg.asSlice(index*sizeof()));
+    public static void f_blocks(MemorySegment struct, long fieldValue) {
+        struct.set(f_blocks$LAYOUT, f_blocks$OFFSET, fieldValue);
     }
-    public static void f_blocks$set(MemorySegment seg, long index, long x) {
-        constants$2.const$5.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfLong f_bfree$LAYOUT = (OfLong)$LAYOUT.select(groupElement("f_bfree"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * fuse_fsblkcnt_t f_bfree
+     * }
+     */
+    public static final OfLong f_bfree$layout() {
+        return f_bfree$LAYOUT;
     }
-    public static VarHandle f_bfree$VH() {
-        return constants$3.const$0;
+
+    private static final long f_bfree$OFFSET = 24;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * fuse_fsblkcnt_t f_bfree
+     * }
+     */
+    public static final long f_bfree$offset() {
+        return f_bfree$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned long long f_bfree;
+     * {@snippet lang=c :
+     * fuse_fsblkcnt_t f_bfree
      * }
      */
-    public static long f_bfree$get(MemorySegment seg) {
-        return (long)constants$3.const$0.get(seg);
+    public static long f_bfree(MemorySegment struct) {
+        return struct.get(f_bfree$LAYOUT, f_bfree$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned long long f_bfree;
+     * {@snippet lang=c :
+     * fuse_fsblkcnt_t f_bfree
      * }
      */
-    public static void f_bfree$set(MemorySegment seg, long x) {
-        constants$3.const$0.set(seg, x);
-    }
-    public static long f_bfree$get(MemorySegment seg, long index) {
-        return (long)constants$3.const$0.get(seg.asSlice(index*sizeof()));
+    public static void f_bfree(MemorySegment struct, long fieldValue) {
+        struct.set(f_bfree$LAYOUT, f_bfree$OFFSET, fieldValue);
     }
-    public static void f_bfree$set(MemorySegment seg, long index, long x) {
-        constants$3.const$0.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfLong f_bavail$LAYOUT = (OfLong)$LAYOUT.select(groupElement("f_bavail"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * fuse_fsblkcnt_t f_bavail
+     * }
+     */
+    public static final OfLong f_bavail$layout() {
+        return f_bavail$LAYOUT;
     }
-    public static VarHandle f_bavail$VH() {
-        return constants$3.const$1;
+
+    private static final long f_bavail$OFFSET = 32;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * fuse_fsblkcnt_t f_bavail
+     * }
+     */
+    public static final long f_bavail$offset() {
+        return f_bavail$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned long long f_bavail;
+     * {@snippet lang=c :
+     * fuse_fsblkcnt_t f_bavail
      * }
      */
-    public static long f_bavail$get(MemorySegment seg) {
-        return (long)constants$3.const$1.get(seg);
+    public static long f_bavail(MemorySegment struct) {
+        return struct.get(f_bavail$LAYOUT, f_bavail$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned long long f_bavail;
+     * {@snippet lang=c :
+     * fuse_fsblkcnt_t f_bavail
      * }
      */
-    public static void f_bavail$set(MemorySegment seg, long x) {
-        constants$3.const$1.set(seg, x);
+    public static void f_bavail(MemorySegment struct, long fieldValue) {
+        struct.set(f_bavail$LAYOUT, f_bavail$OFFSET, fieldValue);
     }
-    public static long f_bavail$get(MemorySegment seg, long index) {
-        return (long)constants$3.const$1.get(seg.asSlice(index*sizeof()));
-    }
-    public static void f_bavail$set(MemorySegment seg, long index, long x) {
-        constants$3.const$1.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfLong f_files$LAYOUT = (OfLong)$LAYOUT.select(groupElement("f_files"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * fuse_fsfilcnt_t f_files
+     * }
+     */
+    public static final OfLong f_files$layout() {
+        return f_files$LAYOUT;
     }
-    public static VarHandle f_files$VH() {
-        return constants$3.const$2;
+
+    private static final long f_files$OFFSET = 40;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * fuse_fsfilcnt_t f_files
+     * }
+     */
+    public static final long f_files$offset() {
+        return f_files$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned long long f_files;
+     * {@snippet lang=c :
+     * fuse_fsfilcnt_t f_files
      * }
      */
-    public static long f_files$get(MemorySegment seg) {
-        return (long)constants$3.const$2.get(seg);
+    public static long f_files(MemorySegment struct) {
+        return struct.get(f_files$LAYOUT, f_files$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned long long f_files;
+     * {@snippet lang=c :
+     * fuse_fsfilcnt_t f_files
      * }
      */
-    public static void f_files$set(MemorySegment seg, long x) {
-        constants$3.const$2.set(seg, x);
-    }
-    public static long f_files$get(MemorySegment seg, long index) {
-        return (long)constants$3.const$2.get(seg.asSlice(index*sizeof()));
+    public static void f_files(MemorySegment struct, long fieldValue) {
+        struct.set(f_files$LAYOUT, f_files$OFFSET, fieldValue);
     }
-    public static void f_files$set(MemorySegment seg, long index, long x) {
-        constants$3.const$2.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfLong f_ffree$LAYOUT = (OfLong)$LAYOUT.select(groupElement("f_ffree"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * fuse_fsfilcnt_t f_ffree
+     * }
+     */
+    public static final OfLong f_ffree$layout() {
+        return f_ffree$LAYOUT;
     }
-    public static VarHandle f_ffree$VH() {
-        return constants$3.const$3;
+
+    private static final long f_ffree$OFFSET = 48;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * fuse_fsfilcnt_t f_ffree
+     * }
+     */
+    public static final long f_ffree$offset() {
+        return f_ffree$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned long long f_ffree;
+     * {@snippet lang=c :
+     * fuse_fsfilcnt_t f_ffree
      * }
      */
-    public static long f_ffree$get(MemorySegment seg) {
-        return (long)constants$3.const$3.get(seg);
+    public static long f_ffree(MemorySegment struct) {
+        return struct.get(f_ffree$LAYOUT, f_ffree$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned long long f_ffree;
+     * {@snippet lang=c :
+     * fuse_fsfilcnt_t f_ffree
      * }
      */
-    public static void f_ffree$set(MemorySegment seg, long x) {
-        constants$3.const$3.set(seg, x);
+    public static void f_ffree(MemorySegment struct, long fieldValue) {
+        struct.set(f_ffree$LAYOUT, f_ffree$OFFSET, fieldValue);
     }
-    public static long f_ffree$get(MemorySegment seg, long index) {
-        return (long)constants$3.const$3.get(seg.asSlice(index*sizeof()));
-    }
-    public static void f_ffree$set(MemorySegment seg, long index, long x) {
-        constants$3.const$3.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfLong f_favail$LAYOUT = (OfLong)$LAYOUT.select(groupElement("f_favail"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * fuse_fsfilcnt_t f_favail
+     * }
+     */
+    public static final OfLong f_favail$layout() {
+        return f_favail$LAYOUT;
     }
-    public static VarHandle f_favail$VH() {
-        return constants$3.const$4;
+
+    private static final long f_favail$OFFSET = 56;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * fuse_fsfilcnt_t f_favail
+     * }
+     */
+    public static final long f_favail$offset() {
+        return f_favail$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned long long f_favail;
+     * {@snippet lang=c :
+     * fuse_fsfilcnt_t f_favail
      * }
      */
-    public static long f_favail$get(MemorySegment seg) {
-        return (long)constants$3.const$4.get(seg);
+    public static long f_favail(MemorySegment struct) {
+        return struct.get(f_favail$LAYOUT, f_favail$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned long long f_favail;
+     * {@snippet lang=c :
+     * fuse_fsfilcnt_t f_favail
      * }
      */
-    public static void f_favail$set(MemorySegment seg, long x) {
-        constants$3.const$4.set(seg, x);
-    }
-    public static long f_favail$get(MemorySegment seg, long index) {
-        return (long)constants$3.const$4.get(seg.asSlice(index*sizeof()));
+    public static void f_favail(MemorySegment struct, long fieldValue) {
+        struct.set(f_favail$LAYOUT, f_favail$OFFSET, fieldValue);
     }
-    public static void f_favail$set(MemorySegment seg, long index, long x) {
-        constants$3.const$4.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfLong f_fsid$LAYOUT = (OfLong)$LAYOUT.select(groupElement("f_fsid"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * uint64_t f_fsid
+     * }
+     */
+    public static final OfLong f_fsid$layout() {
+        return f_fsid$LAYOUT;
     }
-    public static VarHandle f_fsid$VH() {
-        return constants$3.const$5;
+
+    private static final long f_fsid$OFFSET = 64;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * uint64_t f_fsid
+     * }
+     */
+    public static final long f_fsid$offset() {
+        return f_fsid$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned long long f_fsid;
+     * {@snippet lang=c :
+     * uint64_t f_fsid
      * }
      */
-    public static long f_fsid$get(MemorySegment seg) {
-        return (long)constants$3.const$5.get(seg);
+    public static long f_fsid(MemorySegment struct) {
+        return struct.get(f_fsid$LAYOUT, f_fsid$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned long long f_fsid;
+     * {@snippet lang=c :
+     * uint64_t f_fsid
      * }
      */
-    public static void f_fsid$set(MemorySegment seg, long x) {
-        constants$3.const$5.set(seg, x);
-    }
-    public static long f_fsid$get(MemorySegment seg, long index) {
-        return (long)constants$3.const$5.get(seg.asSlice(index*sizeof()));
+    public static void f_fsid(MemorySegment struct, long fieldValue) {
+        struct.set(f_fsid$LAYOUT, f_fsid$OFFSET, fieldValue);
     }
-    public static void f_fsid$set(MemorySegment seg, long index, long x) {
-        constants$3.const$5.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfLong f_flag$LAYOUT = (OfLong)$LAYOUT.select(groupElement("f_flag"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * uint64_t f_flag
+     * }
+     */
+    public static final OfLong f_flag$layout() {
+        return f_flag$LAYOUT;
     }
-    public static VarHandle f_flag$VH() {
-        return constants$4.const$0;
+
+    private static final long f_flag$OFFSET = 72;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * uint64_t f_flag
+     * }
+     */
+    public static final long f_flag$offset() {
+        return f_flag$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned long long f_flag;
+     * {@snippet lang=c :
+     * uint64_t f_flag
      * }
      */
-    public static long f_flag$get(MemorySegment seg) {
-        return (long)constants$4.const$0.get(seg);
+    public static long f_flag(MemorySegment struct) {
+        return struct.get(f_flag$LAYOUT, f_flag$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned long long f_flag;
+     * {@snippet lang=c :
+     * uint64_t f_flag
      * }
      */
-    public static void f_flag$set(MemorySegment seg, long x) {
-        constants$4.const$0.set(seg, x);
+    public static void f_flag(MemorySegment struct, long fieldValue) {
+        struct.set(f_flag$LAYOUT, f_flag$OFFSET, fieldValue);
     }
-    public static long f_flag$get(MemorySegment seg, long index) {
-        return (long)constants$4.const$0.get(seg.asSlice(index*sizeof()));
-    }
-    public static void f_flag$set(MemorySegment seg, long index, long x) {
-        constants$4.const$0.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfLong f_namemax$LAYOUT = (OfLong)$LAYOUT.select(groupElement("f_namemax"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * uint64_t f_namemax
+     * }
+     */
+    public static final OfLong f_namemax$layout() {
+        return f_namemax$LAYOUT;
     }
-    public static VarHandle f_namemax$VH() {
-        return constants$4.const$1;
+
+    private static final long f_namemax$OFFSET = 80;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * uint64_t f_namemax
+     * }
+     */
+    public static final long f_namemax$offset() {
+        return f_namemax$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * unsigned long long f_namemax;
+     * {@snippet lang=c :
+     * uint64_t f_namemax
      * }
      */
-    public static long f_namemax$get(MemorySegment seg) {
-        return (long)constants$4.const$1.get(seg);
+    public static long f_namemax(MemorySegment struct) {
+        return struct.get(f_namemax$LAYOUT, f_namemax$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * unsigned long long f_namemax;
+     * {@snippet lang=c :
+     * uint64_t f_namemax
      * }
      */
-    public static void f_namemax$set(MemorySegment seg, long x) {
-        constants$4.const$1.set(seg, x);
+    public static void f_namemax(MemorySegment struct, long fieldValue) {
+        struct.set(f_namemax$LAYOUT, f_namemax$OFFSET, fieldValue);
     }
-    public static long f_namemax$get(MemorySegment seg, long index) {
-        return (long)constants$4.const$1.get(seg.asSlice(index*sizeof()));
+
+    /**
+     * Obtains a slice of {@code arrayParam} which selects the array element at {@code index}.
+     * The returned segment has address {@code arrayParam.address() + index * layout().byteSize()}
+     */
+    public static MemorySegment asSlice(MemorySegment array, long index) {
+        return array.asSlice(layout().byteSize() * index);
     }
-    public static void f_namemax$set(MemorySegment seg, long index, long x) {
-        constants$4.const$1.set(seg.asSlice(index*sizeof()), x);
+
+    /**
+     * The size (in bytes) of this struct
+     */
+    public static long sizeof() { return layout().byteSize(); }
+
+    /**
+     * Allocate a segment of size {@code layout().byteSize()} using {@code allocator}
+     */
+    public static MemorySegment allocate(SegmentAllocator allocator) {
+        return allocator.allocate(layout());
     }
-    public static long sizeof() { return $LAYOUT().byteSize(); }
-    public static MemorySegment allocate(SegmentAllocator allocator) { return allocator.allocate($LAYOUT()); }
-    public static MemorySegment allocateArray(long len, SegmentAllocator allocator) {
-        return allocator.allocate(MemoryLayout.sequenceLayout(len, $LAYOUT()));
+
+    /**
+     * Allocate an array of size {@code elementCount} using {@code allocator}.
+     * The returned segment has size {@code elementCount * layout().byteSize()}.
+     */
+    public static MemorySegment allocateArray(long elementCount, SegmentAllocator allocator) {
+        return allocator.allocate(MemoryLayout.sequenceLayout(elementCount, layout()));
+    }
+
+    /**
+     * Reinterprets {@code addr} using target {@code arena} and {@code cleanupAction) (if any).
+     * The returned segment has size {@code layout().byteSize()}
+     */
+    public static MemorySegment reinterpret(MemorySegment addr, Arena arena, Consumer<MemorySegment> cleanup) {
+        return reinterpret(addr, 1, arena, cleanup);
     }
-    public static MemorySegment ofAddress(MemorySegment addr, Arena scope) { return RuntimeHelper.asArray(addr, $LAYOUT(), 1, scope); }
-}
 
+    /**
+     * Reinterprets {@code addr} using target {@code arena} and {@code cleanupAction) (if any).
+     * The returned segment has size {@code elementCount * layout().byteSize()}
+     */
+    public static MemorySegment reinterpret(MemorySegment addr, long elementCount, Arena arena, Consumer<MemorySegment> cleanup) {
+        return addr.reinterpret(layout().byteSize() * elementCount, arena, cleanup);
+    }
+}
 
diff --git a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/fuse_timespec.java b/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/fuse_timespec.java
index ea210491..6d78d438 100644
--- a/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/fuse_timespec.java
+++ b/jfuse-win/src/main/java/org/cryptomator/jfuse/win/extr/fuse3/fuse_timespec.java
@@ -2,84 +2,172 @@
 
 package org.cryptomator.jfuse.win.extr.fuse3;
 
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
+import java.lang.invoke.*;
 import java.lang.foreign.*;
+import java.nio.ByteOrder;
+import java.util.*;
+import java.util.function.*;
+import java.util.stream.*;
+
 import static java.lang.foreign.ValueLayout.*;
+import static java.lang.foreign.MemoryLayout.PathElement.*;
+
 /**
- * {@snippet :
+ * {@snippet lang=c :
  * struct fuse_timespec {
- *     long long tv_sec;
- *     long long tv_nsec;
- * };
+ *     int64_t tv_sec;
+ *     int64_t tv_nsec;
+ * }
  * }
  */
 public class fuse_timespec {
 
-    public static MemoryLayout $LAYOUT() {
-        return constants$0.const$0;
+    fuse_timespec() {
+        // Should not be called directly
     }
-    public static VarHandle tv_sec$VH() {
-        return constants$0.const$1;
+
+    private static final GroupLayout $LAYOUT = MemoryLayout.structLayout(
+        fuse_h.C_LONG_LONG.withName("tv_sec"),
+        fuse_h.C_LONG_LONG.withName("tv_nsec")
+    ).withName("fuse_timespec");
+
+    /**
+     * The layout of this struct
+     */
+    public static final GroupLayout layout() {
+        return $LAYOUT;
     }
+
+    private static final OfLong tv_sec$LAYOUT = (OfLong)$LAYOUT.select(groupElement("tv_sec"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int64_t tv_sec
+     * }
+     */
+    public static final OfLong tv_sec$layout() {
+        return tv_sec$LAYOUT;
+    }
+
+    private static final long tv_sec$OFFSET = 0;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int64_t tv_sec
+     * }
+     */
+    public static final long tv_sec$offset() {
+        return tv_sec$OFFSET;
+    }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * long long tv_sec;
+     * {@snippet lang=c :
+     * int64_t tv_sec
      * }
      */
-    public static long tv_sec$get(MemorySegment seg) {
-        return (long)constants$0.const$1.get(seg);
+    public static long tv_sec(MemorySegment struct) {
+        return struct.get(tv_sec$LAYOUT, tv_sec$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * long long tv_sec;
+     * {@snippet lang=c :
+     * int64_t tv_sec
      * }
      */
-    public static void tv_sec$set(MemorySegment seg, long x) {
-        constants$0.const$1.set(seg, x);
-    }
-    public static long tv_sec$get(MemorySegment seg, long index) {
-        return (long)constants$0.const$1.get(seg.asSlice(index*sizeof()));
+    public static void tv_sec(MemorySegment struct, long fieldValue) {
+        struct.set(tv_sec$LAYOUT, tv_sec$OFFSET, fieldValue);
     }
-    public static void tv_sec$set(MemorySegment seg, long index, long x) {
-        constants$0.const$1.set(seg.asSlice(index*sizeof()), x);
+
+    private static final OfLong tv_nsec$LAYOUT = (OfLong)$LAYOUT.select(groupElement("tv_nsec"));
+
+    /**
+     * Layout for field:
+     * {@snippet lang=c :
+     * int64_t tv_nsec
+     * }
+     */
+    public static final OfLong tv_nsec$layout() {
+        return tv_nsec$LAYOUT;
     }
-    public static VarHandle tv_nsec$VH() {
-        return constants$0.const$2;
+
+    private static final long tv_nsec$OFFSET = 8;
+
+    /**
+     * Offset for field:
+     * {@snippet lang=c :
+     * int64_t tv_nsec
+     * }
+     */
+    public static final long tv_nsec$offset() {
+        return tv_nsec$OFFSET;
     }
+
     /**
      * Getter for field:
-     * {@snippet :
-     * long long tv_nsec;
+     * {@snippet lang=c :
+     * int64_t tv_nsec
      * }
      */
-    public static long tv_nsec$get(MemorySegment seg) {
-        return (long)constants$0.const$2.get(seg);
+    public static long tv_nsec(MemorySegment struct) {
+        return struct.get(tv_nsec$LAYOUT, tv_nsec$OFFSET);
     }
+
     /**
      * Setter for field:
-     * {@snippet :
-     * long long tv_nsec;
+     * {@snippet lang=c :
+     * int64_t tv_nsec
      * }
      */
-    public static void tv_nsec$set(MemorySegment seg, long x) {
-        constants$0.const$2.set(seg, x);
+    public static void tv_nsec(MemorySegment struct, long fieldValue) {
+        struct.set(tv_nsec$LAYOUT, tv_nsec$OFFSET, fieldValue);
+    }
+
+    /**
+     * Obtains a slice of {@code arrayParam} which selects the array element at {@code index}.
+     * The returned segment has address {@code arrayParam.address() + index * layout().byteSize()}
+     */
+    public static MemorySegment asSlice(MemorySegment array, long index) {
+        return array.asSlice(layout().byteSize() * index);
+    }
+
+    /**
+     * The size (in bytes) of this struct
+     */
+    public static long sizeof() { return layout().byteSize(); }
+
+    /**
+     * Allocate a segment of size {@code layout().byteSize()} using {@code allocator}
+     */
+    public static MemorySegment allocate(SegmentAllocator allocator) {
+        return allocator.allocate(layout());
     }
-    public static long tv_nsec$get(MemorySegment seg, long index) {
-        return (long)constants$0.const$2.get(seg.asSlice(index*sizeof()));
+
+    /**
+     * Allocate an array of size {@code elementCount} using {@code allocator}.
+     * The returned segment has size {@code elementCount * layout().byteSize()}.
+     */
+    public static MemorySegment allocateArray(long elementCount, SegmentAllocator allocator) {
+        return allocator.allocate(MemoryLayout.sequenceLayout(elementCount, layout()));
     }
-    public static void tv_nsec$set(MemorySegment seg, long index, long x) {
-        constants$0.const$2.set(seg.asSlice(index*sizeof()), x);
+
+    /**
+     * Reinterprets {@code addr} using target {@code arena} and {@code cleanupAction) (if any).
+     * The returned segment has size {@code layout().byteSize()}
+     */
+    public static MemorySegment reinterpret(MemorySegment addr, Arena arena, Consumer<MemorySegment> cleanup) {
+        return reinterpret(addr, 1, arena, cleanup);
     }
-    public static long sizeof() { return $LAYOUT().byteSize(); }
-    public static MemorySegment allocate(SegmentAllocator allocator) { return allocator.allocate($LAYOUT()); }
-    public static MemorySegment allocateArray(long len, SegmentAllocator allocator) {
-        return allocator.allocate(MemoryLayout.sequenceLayout(len, $LAYOUT()));
+
+    /**
+     * Reinterprets {@code addr} using target {@code arena} and {@code cleanupAction) (if any).
+     * The returned segment has size {@code elementCount * layout().byteSize()}
+     */
+    public static MemorySegment reinterpret(MemorySegment addr, long elementCount, Arena arena, Consumer<MemorySegment> cleanup) {
+        return addr.reinterpret(layout().byteSize() * elementCount, arena, cleanup);
     }
-    public static MemorySegment ofAddress(MemorySegment addr, Arena scope) { return RuntimeHelper.asArray(addr, $LAYOUT(), 1, scope); }
 }
 
-
diff --git a/jfuse-win/src/test/java/org/cryptomator/jfuse/win/FileInfoImplTest.java b/jfuse-win/src/test/java/org/cryptomator/jfuse/win/FileInfoImplTest.java
index 12b5a82c..f349e247 100644
--- a/jfuse-win/src/test/java/org/cryptomator/jfuse/win/FileInfoImplTest.java
+++ b/jfuse-win/src/test/java/org/cryptomator/jfuse/win/FileInfoImplTest.java
@@ -22,7 +22,7 @@ public class FileInfoImplTest {
 	public void testGetOpenFlags(int flags, Set<OpenOption> expectedResult) {
 		try (var arena = Arena.ofConfined()) {
 			var fi = new FileInfoImpl(fuse3_file_info.allocate(arena));
-			fuse3_file_info.flags$set(fi.segment(), flags);
+			fuse3_file_info.flags(fi.segment(), flags);
 
 			var result = fi.getOpenFlags();
 
diff --git a/jfuse-win/src/test/java/org/cryptomator/jfuse/win/FuseConfigImplTest.java b/jfuse-win/src/test/java/org/cryptomator/jfuse/win/FuseConfigImplTest.java
index 3e1485f9..17ca5220 100644
--- a/jfuse-win/src/test/java/org/cryptomator/jfuse/win/FuseConfigImplTest.java
+++ b/jfuse-win/src/test/java/org/cryptomator/jfuse/win/FuseConfigImplTest.java
@@ -23,7 +23,7 @@ public class FuseConfigImplTest {
 	public void testGetters(SetInMemorySegment<Number> setter, GetInFuseConfig<Number> getter, Number value) {
 		try (var arena = Arena.ofConfined()) {
 			var segment = fuse3_config.allocate(arena);
-			var fuseConfig = new FuseConfigImpl(segment, arena);
+			var fuseConfig = new FuseConfigImpl(segment);
 
 			setter.accept(segment, value);
 
@@ -33,27 +33,27 @@ public void testGetters(SetInMemorySegment<Number> setter, GetInFuseConfig<Numbe
 
 	public static Stream<Arguments> testGetters() {
 		return Stream.of(
-				Arguments.arguments((SetInMemorySegment<Integer>) fuse3_config::set_gid$set, Named.of("setGid()", (GetInFuseConfig<Integer>) FuseConfig::setGid), 42),
-				Arguments.arguments((SetInMemorySegment<Integer>) fuse3_config::gid$set, Named.of("gid()", (GetInFuseConfig<Integer>) FuseConfig::gid), 42),
-				Arguments.arguments((SetInMemorySegment<Integer>) fuse3_config::set_uid$set, Named.of("setUid()", (GetInFuseConfig<Integer>) FuseConfig::setUid), 42),
-				Arguments.arguments((SetInMemorySegment<Integer>) fuse3_config::uid$set, Named.of("uid()", (GetInFuseConfig<Integer>) FuseConfig::uid), 42),
-				Arguments.arguments((SetInMemorySegment<Integer>) fuse3_config::set_mode$set, Named.of("setMode()", (GetInFuseConfig<Integer>) FuseConfig::setMode), 42),
-				Arguments.arguments((SetInMemorySegment<Integer>) fuse3_config::umask$set, Named.of("umask()", (GetInFuseConfig<Integer>) FuseConfig::umask), 42),
-				Arguments.arguments((SetInMemorySegment<Double>) fuse3_config::entry_timeout$set, Named.of("entryTimeout()", (GetInFuseConfig<Double>) FuseConfig::entryTimeout), 4.2),
-				Arguments.arguments((SetInMemorySegment<Double>) fuse3_config::negative_timeout$set, Named.of("negativeTimeout()", (GetInFuseConfig<Double>) FuseConfig::negativeTimeout), 4.2),
-				Arguments.arguments((SetInMemorySegment<Double>) fuse3_config::attr_timeout$set, Named.of("attrTimeout()", (GetInFuseConfig<Double>) FuseConfig::attrTimeout), 4.2),
-				Arguments.arguments((SetInMemorySegment<Integer>) fuse3_config::intr$set, Named.of("intr()", (GetInFuseConfig<Integer>) FuseConfig::intr), 42),
-				Arguments.arguments((SetInMemorySegment<Integer>) fuse3_config::intr_signal$set, Named.of("intrSignal()", (GetInFuseConfig<Integer>) FuseConfig::intrSignal), 42),
-				Arguments.arguments((SetInMemorySegment<Integer>) fuse3_config::remember$set, Named.of("remember()", (GetInFuseConfig<Integer>) FuseConfig::remember), 42),
-				Arguments.arguments((SetInMemorySegment<Integer>) fuse3_config::hard_remove$set, Named.of("hardRemove()", (GetInFuseConfig<Integer>) FuseConfig::hardRemove), 42),
-				Arguments.arguments((SetInMemorySegment<Integer>) fuse3_config::use_ino$set, Named.of("useIno()", (GetInFuseConfig<Integer>) FuseConfig::useIno), 42),
-				Arguments.arguments((SetInMemorySegment<Integer>) fuse3_config::readdir_ino$set, Named.of("readdirIno()", (GetInFuseConfig<Integer>) FuseConfig::readdirIno), 42),
-				Arguments.arguments((SetInMemorySegment<Integer>) fuse3_config::direct_io$set, Named.of("directIo()", (GetInFuseConfig<Integer>) FuseConfig::directIo), 42),
-				Arguments.arguments((SetInMemorySegment<Integer>) fuse3_config::kernel_cache$set, Named.of("kernelCache()", (GetInFuseConfig<Integer>) FuseConfig::kernelCache), 42),
-				Arguments.arguments((SetInMemorySegment<Integer>) fuse3_config::auto_cache$set, Named.of("autoCache()", (GetInFuseConfig<Integer>) FuseConfig::autoCache), 42),
-				Arguments.arguments((SetInMemorySegment<Integer>) fuse3_config::ac_attr_timeout_set$set, Named.of("acAtrrTimeoutSet()", (GetInFuseConfig<Integer>) FuseConfig::acAttrTimeoutSet), 42),
-				Arguments.arguments((SetInMemorySegment<Double>) fuse3_config::ac_attr_timeout$set, Named.of("acAttrTimeout()", (GetInFuseConfig<Double>) FuseConfig::acAttrTimeout), 4.2),
-				Arguments.arguments((SetInMemorySegment<Integer>) fuse3_config::nullpath_ok$set, Named.of("nullpathOk()", (GetInFuseConfig<Integer>) FuseConfig::nullpathOk), 42)
+				Arguments.arguments((SetInMemorySegment<Integer>) fuse3_config::set_gid, Named.of("setGid()", (GetInFuseConfig<Integer>) FuseConfig::setGid), 42),
+				Arguments.arguments((SetInMemorySegment<Integer>) fuse3_config::gid, Named.of("gid()", (GetInFuseConfig<Integer>) FuseConfig::gid), 42),
+				Arguments.arguments((SetInMemorySegment<Integer>) fuse3_config::set_uid, Named.of("setUid()", (GetInFuseConfig<Integer>) FuseConfig::setUid), 42),
+				Arguments.arguments((SetInMemorySegment<Integer>) fuse3_config::uid, Named.of("uid()", (GetInFuseConfig<Integer>) FuseConfig::uid), 42),
+				Arguments.arguments((SetInMemorySegment<Integer>) fuse3_config::set_mode, Named.of("setMode()", (GetInFuseConfig<Integer>) FuseConfig::setMode), 42),
+				Arguments.arguments((SetInMemorySegment<Integer>) fuse3_config::umask, Named.of("umask()", (GetInFuseConfig<Integer>) FuseConfig::umask), 42),
+				Arguments.arguments((SetInMemorySegment<Double>) fuse3_config::entry_timeout, Named.of("entryTimeout()", (GetInFuseConfig<Double>) FuseConfig::entryTimeout), 4.2),
+				Arguments.arguments((SetInMemorySegment<Double>) fuse3_config::negative_timeout, Named.of("negativeTimeout()", (GetInFuseConfig<Double>) FuseConfig::negativeTimeout), 4.2),
+				Arguments.arguments((SetInMemorySegment<Double>) fuse3_config::attr_timeout, Named.of("attrTimeout()", (GetInFuseConfig<Double>) FuseConfig::attrTimeout), 4.2),
+				Arguments.arguments((SetInMemorySegment<Integer>) fuse3_config::intr, Named.of("intr()", (GetInFuseConfig<Integer>) FuseConfig::intr), 42),
+				Arguments.arguments((SetInMemorySegment<Integer>) fuse3_config::intr_signal, Named.of("intrSignal()", (GetInFuseConfig<Integer>) FuseConfig::intrSignal), 42),
+				Arguments.arguments((SetInMemorySegment<Integer>) fuse3_config::remember, Named.of("remember()", (GetInFuseConfig<Integer>) FuseConfig::remember), 42),
+				Arguments.arguments((SetInMemorySegment<Integer>) fuse3_config::hard_remove, Named.of("hardRemove()", (GetInFuseConfig<Integer>) FuseConfig::hardRemove), 42),
+				Arguments.arguments((SetInMemorySegment<Integer>) fuse3_config::use_ino, Named.of("useIno()", (GetInFuseConfig<Integer>) FuseConfig::useIno), 42),
+				Arguments.arguments((SetInMemorySegment<Integer>) fuse3_config::readdir_ino, Named.of("readdirIno()", (GetInFuseConfig<Integer>) FuseConfig::readdirIno), 42),
+				Arguments.arguments((SetInMemorySegment<Integer>) fuse3_config::direct_io, Named.of("directIo()", (GetInFuseConfig<Integer>) FuseConfig::directIo), 42),
+				Arguments.arguments((SetInMemorySegment<Integer>) fuse3_config::kernel_cache, Named.of("kernelCache()", (GetInFuseConfig<Integer>) FuseConfig::kernelCache), 42),
+				Arguments.arguments((SetInMemorySegment<Integer>) fuse3_config::auto_cache, Named.of("autoCache()", (GetInFuseConfig<Integer>) FuseConfig::autoCache), 42),
+				Arguments.arguments((SetInMemorySegment<Integer>) fuse3_config::ac_attr_timeout_set, Named.of("acAtrrTimeoutSet()", (GetInFuseConfig<Integer>) FuseConfig::acAttrTimeoutSet), 42),
+				Arguments.arguments((SetInMemorySegment<Double>) fuse3_config::ac_attr_timeout, Named.of("acAttrTimeout()", (GetInFuseConfig<Double>) FuseConfig::acAttrTimeout), 4.2),
+				Arguments.arguments((SetInMemorySegment<Integer>) fuse3_config::nullpath_ok, Named.of("nullpathOk()", (GetInFuseConfig<Integer>) FuseConfig::nullpathOk), 42)
 		);
 	}
 
diff --git a/jfuse-win/src/test/java/org/cryptomator/jfuse/win/FuseConnInfoImplTest.java b/jfuse-win/src/test/java/org/cryptomator/jfuse/win/FuseConnInfoImplTest.java
index dc9ca660..121a4bf9 100644
--- a/jfuse-win/src/test/java/org/cryptomator/jfuse/win/FuseConnInfoImplTest.java
+++ b/jfuse-win/src/test/java/org/cryptomator/jfuse/win/FuseConnInfoImplTest.java
@@ -23,7 +23,7 @@ public class FuseConnInfoImplTest {
 	public void testGetters(SetInMemorySegment setter, GetInConnInfo getter) {
 		try (var arena = Arena.ofConfined()) {
 			var segment = fuse3_conn_info.allocate(arena);
-			var connInfo = new FuseConnInfoImpl(segment, arena);
+			var connInfo = new FuseConnInfoImpl(segment);
 
 			setter.accept(segment, 42);
 
@@ -33,16 +33,16 @@ public void testGetters(SetInMemorySegment setter, GetInConnInfo getter) {
 
 	public static Stream<Arguments> testGetters() {
 		return Stream.of(
-				Arguments.arguments((SetInMemorySegment) fuse3_conn_info::proto_major$set, Named.of("protoMajor()", (GetInConnInfo) FuseConnInfo::protoMajor)),
-				Arguments.arguments((SetInMemorySegment) fuse3_conn_info::proto_minor$set, Named.of("protoMinor()", (GetInConnInfo) FuseConnInfo::protoMinor)),
-				Arguments.arguments((SetInMemorySegment) fuse3_conn_info::capable$set, Named.of("capable()", (GetInConnInfo) FuseConnInfo::capable)),
-				Arguments.arguments((SetInMemorySegment) fuse3_conn_info::max_write$set, Named.of("maxWrite()", (GetInConnInfo) FuseConnInfo::maxWrite)),
-				Arguments.arguments((SetInMemorySegment) fuse3_conn_info::max_read$set, Named.of("maxRead()", (GetInConnInfo) FuseConnInfo::maxRead)),
-				Arguments.arguments((SetInMemorySegment) fuse3_conn_info::max_readahead$set, Named.of("maxReadahead()", (GetInConnInfo) FuseConnInfo::maxReadahead)),
-				Arguments.arguments((SetInMemorySegment) fuse3_conn_info::max_background$set, Named.of("maxBackground()", (GetInConnInfo) FuseConnInfo::maxBackground)),
-				Arguments.arguments((SetInMemorySegment) fuse3_conn_info::congestion_threshold$set, Named.of("congestionThreshold()", (GetInConnInfo) FuseConnInfo::congestionThreshold)),
-				Arguments.arguments((SetInMemorySegment) fuse3_conn_info::time_gran$set, Named.of("timeGran()", (GetInConnInfo) FuseConnInfo::timeGran)),
-				Arguments.arguments((SetInMemorySegment) fuse3_conn_info::want$set, Named.of("want()", (GetInConnInfo) FuseConnInfo::want))
+				Arguments.arguments((SetInMemorySegment) fuse3_conn_info::proto_major, Named.of("protoMajor()", (GetInConnInfo) FuseConnInfo::protoMajor)),
+				Arguments.arguments((SetInMemorySegment) fuse3_conn_info::proto_minor, Named.of("protoMinor()", (GetInConnInfo) FuseConnInfo::protoMinor)),
+				Arguments.arguments((SetInMemorySegment) fuse3_conn_info::capable, Named.of("capable()", (GetInConnInfo) FuseConnInfo::capable)),
+				Arguments.arguments((SetInMemorySegment) fuse3_conn_info::max_write, Named.of("maxWrite()", (GetInConnInfo) FuseConnInfo::maxWrite)),
+				Arguments.arguments((SetInMemorySegment) fuse3_conn_info::max_read, Named.of("maxRead()", (GetInConnInfo) FuseConnInfo::maxRead)),
+				Arguments.arguments((SetInMemorySegment) fuse3_conn_info::max_readahead, Named.of("maxReadahead()", (GetInConnInfo) FuseConnInfo::maxReadahead)),
+				Arguments.arguments((SetInMemorySegment) fuse3_conn_info::max_background, Named.of("maxBackground()", (GetInConnInfo) FuseConnInfo::maxBackground)),
+				Arguments.arguments((SetInMemorySegment) fuse3_conn_info::congestion_threshold, Named.of("congestionThreshold()", (GetInConnInfo) FuseConnInfo::congestionThreshold)),
+				Arguments.arguments((SetInMemorySegment) fuse3_conn_info::time_gran, Named.of("timeGran()", (GetInConnInfo) FuseConnInfo::timeGran)),
+				Arguments.arguments((SetInMemorySegment) fuse3_conn_info::want, Named.of("want()", (GetInConnInfo) FuseConnInfo::want))
 		);
 	}
 
@@ -56,7 +56,7 @@ private interface GetInConnInfo extends Function<FuseConnInfo, Integer> {}
 	public void testSetters(SetInConnInfo setter, GetInMemorySegment getter) {
 		try (var arena = Arena.ofConfined()) {
 			var segment = fuse3_conn_info.allocate(arena);
-			var connInfo = new FuseConnInfoImpl(segment, arena);
+			var connInfo = new FuseConnInfoImpl(segment);
 
 			setter.accept(connInfo, 42);
 
@@ -66,13 +66,13 @@ public void testSetters(SetInConnInfo setter, GetInMemorySegment getter) {
 
 	public static Stream<Arguments> testSetters() {
 		return Stream.of(
-				Arguments.arguments(Named.of("setWant()", (SetInConnInfo) FuseConnInfo::setWant), (GetInMemorySegment) fuse3_conn_info::want$get),
-				Arguments.arguments(Named.of("setMaxWrite()", (SetInConnInfo) FuseConnInfo::setMaxWrite), (GetInMemorySegment) fuse3_conn_info::max_write$get),
-				Arguments.arguments(Named.of("setMaxRead()", (SetInConnInfo) FuseConnInfo::setMaxRead), (GetInMemorySegment) fuse3_conn_info::max_read$get),
-				Arguments.arguments(Named.of("setMaxReadahead()", (SetInConnInfo) FuseConnInfo::setMaxReadahead), (GetInMemorySegment) fuse3_conn_info::max_readahead$get),
-				Arguments.arguments(Named.of("setMaxBackground()", (SetInConnInfo) FuseConnInfo::setMaxBackground), (GetInMemorySegment) fuse3_conn_info::max_background$get),
-				Arguments.arguments(Named.of("setCongestionThreshold()", (SetInConnInfo) FuseConnInfo::setCongestionThreshold), (GetInMemorySegment) fuse3_conn_info::congestion_threshold$get),
-				Arguments.arguments(Named.of("setTimeGran()", (SetInConnInfo) FuseConnInfo::setTimeGran), (GetInMemorySegment) fuse3_conn_info::time_gran$get)
+				Arguments.arguments(Named.of("setWant()", (SetInConnInfo) FuseConnInfo::setWant), (GetInMemorySegment) fuse3_conn_info::want),
+				Arguments.arguments(Named.of("setMaxWrite()", (SetInConnInfo) FuseConnInfo::setMaxWrite), (GetInMemorySegment) fuse3_conn_info::max_write),
+				Arguments.arguments(Named.of("setMaxRead()", (SetInConnInfo) FuseConnInfo::setMaxRead), (GetInMemorySegment) fuse3_conn_info::max_read),
+				Arguments.arguments(Named.of("setMaxReadahead()", (SetInConnInfo) FuseConnInfo::setMaxReadahead), (GetInMemorySegment) fuse3_conn_info::max_readahead),
+				Arguments.arguments(Named.of("setMaxBackground()", (SetInConnInfo) FuseConnInfo::setMaxBackground), (GetInMemorySegment) fuse3_conn_info::max_background),
+				Arguments.arguments(Named.of("setCongestionThreshold()", (SetInConnInfo) FuseConnInfo::setCongestionThreshold), (GetInMemorySegment) fuse3_conn_info::congestion_threshold),
+				Arguments.arguments(Named.of("setTimeGran()", (SetInConnInfo) FuseConnInfo::setTimeGran), (GetInMemorySegment) fuse3_conn_info::time_gran)
 		);
 	}
 
diff --git a/jfuse-win/src/test/java/org/cryptomator/jfuse/win/FuseImplTest.java b/jfuse-win/src/test/java/org/cryptomator/jfuse/win/FuseImplTest.java
index dc6c1170..78a64e0b 100644
--- a/jfuse-win/src/test/java/org/cryptomator/jfuse/win/FuseImplTest.java
+++ b/jfuse-win/src/test/java/org/cryptomator/jfuse/win/FuseImplTest.java
@@ -118,7 +118,7 @@ public void testParseArgs() {
 				MemorySegment mp = invocation.getArgument(1);
 				MemorySegment mt = invocation.getArgument(2);
 				MemorySegment fg = invocation.getArgument(3);
-				mp.set(ValueLayout.ADDRESS, 0L, arena.allocateUtf8String("/mount/point"));
+				mp.set(ValueLayout.ADDRESS, 0L, arena.allocateFrom("/mount/point"));
 				mt.set(JAVA_INT, 0L, 1);
 				fg.set(JAVA_INT, 0L, 1);
 				return 0;
@@ -142,7 +142,7 @@ public class FlushFsyncFsyncdir {
 		@DisplayName("flush(\"/foo\", fi)")
 		public void testFlush() {
 			try (var arena = Arena.ofConfined()) {
-				var path = arena.allocateUtf8String("/foo");
+				var path = arena.allocateFrom("/foo");
 				var fi = fuse3_file_info.allocate(arena);
 				Mockito.doReturn(42).when(fuseOps).flush(Mockito.eq("/foo"), Mockito.any());
 
@@ -156,7 +156,7 @@ public void testFlush() {
 		@DisplayName("fsync(\"/foo\", 1, fi)")
 		public void testFsync() {
 			try (var arena = Arena.ofConfined()) {
-				var path = arena.allocateUtf8String("/foo");
+				var path = arena.allocateFrom("/foo");
 				var fi = fuse3_file_info.allocate(arena);
 				Mockito.doReturn(42).when(fuseOps).fsync(Mockito.eq("/foo"), Mockito.eq(1), Mockito.any());
 
@@ -170,7 +170,7 @@ public void testFsync() {
 		@DisplayName("fsyncdir(\"/foo\", 1, fi)")
 		public void testFsyncdir() {
 			try (var arena = Arena.ofConfined()) {
-				var path = arena.allocateUtf8String("/foo");
+				var path = arena.allocateFrom("/foo");
 				var fi = fuse3_file_info.allocate(arena);
 				Mockito.doReturn(42).when(fuseOps).fsyncdir(Mockito.eq("/foo"), Mockito.eq(1), Mockito.any());
 
@@ -211,13 +211,13 @@ public void testUtimens(long sec0, long nsec0, long sec1, long nsec1) {
 		Instant expectedATime = Instant.ofEpochSecond(sec0, nsec0);
 		Instant expectedMTime = Instant.ofEpochSecond(sec1, nsec1);
 		try (var arena = Arena.ofConfined()) {
-			var path = arena.allocateUtf8String("/foo");
+			var path = arena.allocateFrom("/foo");
 			var times = fuse_timespec.allocateArray(2, arena);
-			var fi = arena.allocate(fuse3_file_info.$LAYOUT());
-			fuse_timespec.tv_sec$set(times, 0, sec0);
-			fuse_timespec.tv_nsec$set(times, 0, nsec0);
-			fuse_timespec.tv_sec$set(times, 1, sec1);
-			fuse_timespec.tv_nsec$set(times, 1, nsec1);
+			var fi = fuse3_file_info.allocate(arena);
+			fuse_timespec.tv_sec(fuse_timespec.asSlice(times, 0), sec0);
+			fuse_timespec.tv_nsec(fuse_timespec.asSlice(times, 0), nsec0);
+			fuse_timespec.tv_sec(fuse_timespec.asSlice(times, 1), sec1);
+			fuse_timespec.tv_nsec(fuse_timespec.asSlice(times, 1), nsec1);
 			Mockito.doReturn(42).when(fuseOps).utimens(Mockito.eq("/foo"), Mockito.argThat(t -> expectedATime.equals(t.get())), Mockito.argThat(t -> expectedMTime.equals(t.get())), Mockito.argThat(usesSameMemorySegement(fi)));
 
 			var result = fuseImpl.utimens(path, times, fi);
@@ -234,9 +234,9 @@ public class Attr {
 		@DisplayName("getattr")
 		public void testGetattr() {
 			try (var arena = Arena.ofConfined()) {
-				var path = arena.allocateUtf8String("/foo");
+				var path = arena.allocateFrom("/foo");
 				var attr = fuse_stat.allocate(arena);
-				var fi = arena.allocate(fuse3_file_info.$LAYOUT());
+				var fi = fuse3_file_info.allocate(arena);
 				Mockito.doReturn(42).when(fuseOps).getattr(Mockito.eq("/foo"), Mockito.any(), Mockito.argThat(usesSameMemorySegement(fi)));
 
 				var result = fuseImpl.getattr(path, attr, fi);
@@ -249,8 +249,8 @@ public void testGetattr() {
 		@DisplayName("getxattr")
 		public void testGetxattr() {
 			try (var arena = Arena.ofConfined()) {
-				var path = arena.allocateUtf8String("/foo");
-				var name = arena.allocateUtf8String("bar");
+				var path = arena.allocateFrom("/foo");
+				var name = arena.allocateFrom("bar");
 				var value = arena.allocate(100);
 
 				Mockito.doReturn(42).when(fuseOps).getxattr(Mockito.eq("/foo"), Mockito.eq("bar"), Mockito.any());
@@ -265,8 +265,8 @@ public void testGetxattr() {
 		@DisplayName("setxattr")
 		public void testSetxattr() {
 			try (var arena = Arena.ofConfined()) {
-				var path = arena.allocateUtf8String("/foo");
-				var name = arena.allocateUtf8String("bar");
+				var path = arena.allocateFrom("/foo");
+				var name = arena.allocateFrom("bar");
 				var value = arena.allocate(100);
 
 				Mockito.doReturn(42).when(fuseOps).setxattr(Mockito.eq("/foo"), Mockito.eq("bar"), Mockito.any(), Mockito.anyInt());
@@ -281,7 +281,7 @@ public void testSetxattr() {
 		@DisplayName("listxattr")
 		public void testListxattr() {
 			try (var arena = Arena.ofConfined()) {
-				var path = arena.allocateUtf8String("/foo");
+				var path = arena.allocateFrom("/foo");
 				var list = arena.allocate(100);
 
 				Mockito.doReturn(42).when(fuseOps).listxattr(Mockito.eq("/foo"), Mockito.any());
@@ -296,8 +296,8 @@ public void testListxattr() {
 		@DisplayName("removexattr")
 		public void testRemovexattr() {
 			try (var arena = Arena.ofConfined()) {
-				var path = arena.allocateUtf8String("/foo");
-				var name = arena.allocateUtf8String("bar");
+				var path = arena.allocateFrom("/foo");
+				var name = arena.allocateFrom("bar");
 
 				Mockito.doReturn(42).when(fuseOps).removexattr(Mockito.eq("/foo"), Mockito.eq("bar"));
 
@@ -314,8 +314,8 @@ public void testRemovexattr() {
 	@DisplayName("truncate")
 	public void testTruncate() {
 		try (var arena = Arena.ofConfined()) {
-			var path = arena.allocateUtf8String("/foo");
-			var fi = arena.allocate(fuse3_file_info.$LAYOUT());
+			var path = arena.allocateFrom("/foo");
+			var fi = fuse3_file_info.allocate(arena);
 			Mockito.doReturn(42).when(fuseOps).truncate(Mockito.eq("/foo"), Mockito.eq(1337L), Mockito.argThat(usesSameMemorySegement(fi)));
 
 			var result = fuseImpl.truncate(path, 1337L, fi);
@@ -328,7 +328,7 @@ public void testTruncate() {
 	@DisplayName("chown")
 	public void testChown() {
 		try (var arena = Arena.ofConfined()) {
-			var path = arena.allocateUtf8String("/foo");
+			var path = arena.allocateFrom("/foo");
 			var fi = fuse3_file_info.allocate(arena);
 			Mockito.doReturn(42).when(fuseOps).chown(Mockito.eq("/foo"), Mockito.eq(42), Mockito.eq(1337), Mockito.any());
 
diff --git a/jfuse-win/src/test/java/org/cryptomator/jfuse/win/StatImplTest.java b/jfuse-win/src/test/java/org/cryptomator/jfuse/win/StatImplTest.java
index 3e775800..102563d7 100644
--- a/jfuse-win/src/test/java/org/cryptomator/jfuse/win/StatImplTest.java
+++ b/jfuse-win/src/test/java/org/cryptomator/jfuse/win/StatImplTest.java
@@ -23,7 +23,7 @@ public class StatImplTest {
 	public void testGetters(SetInMemorySegment<Number> setter, GetInStat<Number> getter, Number value) {
 		try (var arena = Arena.ofConfined()) {
 			var segment = fuse_stat.allocate(arena);
-			var stat = new StatImpl(segment, arena);
+			var stat = new StatImpl(segment);
 
 			setter.accept(segment, value);
 
@@ -33,11 +33,11 @@ public void testGetters(SetInMemorySegment<Number> setter, GetInStat<Number> get
 
 	public static Stream<Arguments> testGetters() {
 		return Stream.of(
-				Arguments.arguments((SetInMemorySegment<Integer>) fuse_stat::st_mode$set, Named.of("getMode()", (GetInStat<Integer>) Stat::getMode), 42),
-				Arguments.arguments((SetInMemorySegment<Integer>) fuse_stat::st_uid$set, Named.of("getUid()", (GetInStat<Integer>) Stat::getUid), 42),
-				Arguments.arguments((SetInMemorySegment<Integer>) fuse_stat::st_gid$set, Named.of("getGid()", (GetInStat<Integer>) Stat::getGid), 42),
-				Arguments.arguments((SetInMemorySegment<Short>) fuse_stat::st_nlink$set, Named.of("getNLink()", (GetInStat<Long>) Stat::getNLink), (short) 42),
-				Arguments.arguments((SetInMemorySegment<Long>) fuse_stat::st_size$set, Named.of("getSize()", (GetInStat<Long>) Stat::getSize), 42L)
+				Arguments.arguments((SetInMemorySegment<Integer>) fuse_stat::st_mode, Named.of("getMode()", (GetInStat<Integer>) Stat::getMode), 42),
+				Arguments.arguments((SetInMemorySegment<Integer>) fuse_stat::st_uid, Named.of("getUid()", (GetInStat<Integer>) Stat::getUid), 42),
+				Arguments.arguments((SetInMemorySegment<Integer>) fuse_stat::st_gid, Named.of("getGid()", (GetInStat<Integer>) Stat::getGid), 42),
+				Arguments.arguments((SetInMemorySegment<Short>) fuse_stat::st_nlink, Named.of("getNLink()", (GetInStat<Long>) Stat::getNLink), (short) 42),
+				Arguments.arguments((SetInMemorySegment<Long>) fuse_stat::st_size, Named.of("getSize()", (GetInStat<Long>) Stat::getSize), 42L)
 		);
 	}
 
@@ -51,7 +51,7 @@ private interface GetInStat<T> extends Function<Stat, T> {}
 	public void testSetters(SetInStat<Number> setter, GetInMemorySegment<Number> getter, Number value) {
 		try (var arena = Arena.ofConfined()) {
 			var segment = fuse_stat.allocate(arena);
-			var stat = new StatImpl(segment, arena);
+			var stat = new StatImpl(segment);
 
 			setter.accept(stat, value);
 
@@ -61,11 +61,11 @@ public void testSetters(SetInStat<Number> setter, GetInMemorySegment<Number> get
 
 	public static Stream<Arguments> testSetters() {
 		return Stream.of(
-				Arguments.arguments(Named.of("setMode()", (SetInStat<Integer>) Stat::setMode), (GetInMemorySegment<Integer>) fuse_stat::st_mode$get, 42),
-				Arguments.arguments(Named.of("setUid()", (SetInStat<Integer>) Stat::setUid), (GetInMemorySegment<Integer>) fuse_stat::st_uid$get, 42),
-				Arguments.arguments(Named.of("setGid()", (SetInStat<Integer>) Stat::setGid), (GetInMemorySegment<Integer>) fuse_stat::st_gid$get, 42),
-				Arguments.arguments(Named.of("setNLink()", (SetInStat<Short>) Stat::setNLink), (GetInMemorySegment<Short>) fuse_stat::st_nlink$get, (short) 42),
-				Arguments.arguments(Named.of("setSize()", (SetInStat<Long>) Stat::setSize), (GetInMemorySegment<Long>) fuse_stat::st_size$get, 42L)
+				Arguments.arguments(Named.of("setMode()", (SetInStat<Integer>) Stat::setMode), (GetInMemorySegment<Integer>) fuse_stat::st_mode, 42),
+				Arguments.arguments(Named.of("setUid()", (SetInStat<Integer>) Stat::setUid), (GetInMemorySegment<Integer>) fuse_stat::st_uid, 42),
+				Arguments.arguments(Named.of("setGid()", (SetInStat<Integer>) Stat::setGid), (GetInMemorySegment<Integer>) fuse_stat::st_gid, 42),
+				Arguments.arguments(Named.of("setNLink()", (SetInStat<Short>) Stat::setNLink), (GetInMemorySegment<Short>) fuse_stat::st_nlink, (short) 42),
+				Arguments.arguments(Named.of("setSize()", (SetInStat<Long>) Stat::setSize), (GetInMemorySegment<Long>) fuse_stat::st_size, 42L)
 		);
 	}
 
diff --git a/jfuse-win/src/test/java/org/cryptomator/jfuse/win/TimeSpecImplTest.java b/jfuse-win/src/test/java/org/cryptomator/jfuse/win/TimeSpecImplTest.java
index e447ec1a..2bc60b7e 100644
--- a/jfuse-win/src/test/java/org/cryptomator/jfuse/win/TimeSpecImplTest.java
+++ b/jfuse-win/src/test/java/org/cryptomator/jfuse/win/TimeSpecImplTest.java
@@ -15,8 +15,8 @@ public class TimeSpecImplTest {
 	public void testGet() {
 		try (var arena = Arena.ofConfined()) {
 			var timeSpec = new TimeSpecImpl(fuse_timespec.allocate(arena));
-			fuse_timespec.tv_sec$set(timeSpec.segment(), 123L);
-			fuse_timespec.tv_nsec$set(timeSpec.segment(), 456L);
+			fuse_timespec.tv_sec(timeSpec.segment(), 123L);
+			fuse_timespec.tv_nsec(timeSpec.segment(), 456L);
 
 			var result = timeSpec.get();
 
@@ -30,13 +30,13 @@ public void testGet() {
 	public void testSet() {
 		try (var arena = Arena.ofConfined()) {
 			var timeSpec = new TimeSpecImpl(fuse_timespec.allocate(arena));
-			fuse_timespec.tv_sec$set(timeSpec.segment(), 0L);
-			fuse_timespec.tv_nsec$set(timeSpec.segment(), 0L);
+			fuse_timespec.tv_sec(timeSpec.segment(), 0L);
+			fuse_timespec.tv_nsec(timeSpec.segment(), 0L);
 
 			timeSpec.set(Instant.ofEpochSecond(123L, 456L));
 
-			Assertions.assertEquals(123L, fuse_timespec.tv_sec$get(timeSpec.segment()));
-			Assertions.assertEquals(456L, fuse_timespec.tv_nsec$get(timeSpec.segment()));
+			Assertions.assertEquals(123L, fuse_timespec.tv_sec(timeSpec.segment()));
+			Assertions.assertEquals(456L, fuse_timespec.tv_nsec(timeSpec.segment()));
 		}
 	}
 
diff --git a/jfuse/pom.xml b/jfuse/pom.xml
index 67920ee3..e378f5ae 100644
--- a/jfuse/pom.xml
+++ b/jfuse/pom.xml
@@ -52,7 +52,6 @@
 					<additionalOptions>
 						<option>--module org.cryptomator.jfuse</option>
 						<option>--expand-requires transitive</option>
-						<option>--enable-preview</option>
 					</additionalOptions>
 					<includeDependencySources>true</includeDependencySources>
 					<dependencySourceIncludes>
diff --git a/pom.xml b/pom.xml
index 0362ec89..07c49b38 100644
--- a/pom.xml
+++ b/pom.xml
@@ -84,12 +84,9 @@
 					<artifactId>maven-compiler-plugin</artifactId>
 					<version>3.12.1</version>
 					<configuration>
-						<release>21</release>
+						<release>22</release>
 						<encoding>UTF-8</encoding>
 						<showWarnings>true</showWarnings>
-						<compilerArgs>
-							<compilerArg>--enable-preview</compilerArg>
-						</compilerArgs>
 					</configuration>
 				</plugin>
 				<plugin>
@@ -188,10 +185,7 @@
 				</executions>
 				<configuration>
 					<excludePackageNames>*.extr:*.extr.*</excludePackageNames>
-					<release>21</release>
-					<additionalOptions>
-						<option>--enable-preview</option>
-					</additionalOptions>
+					<release>22</release>
 				</configuration>
 			</plugin>
 			<plugin>