diff --git a/bom/pom.xml b/bom/pom.xml
index cfd9a3835f8..8b52f7c2885 100644
--- a/bom/pom.xml
+++ b/bom/pom.xml
@@ -898,6 +898,11 @@
                 <artifactId>helidon-mp-graal-native-image-extension</artifactId>
                 <version>${helidon.version}</version>
             </dependency>
+            <dependency>
+                <groupId>io.helidon.integrations.crac</groupId>
+                <artifactId>helidon-integrations-crac</artifactId>
+                <version>${helidon.version}</version>
+            </dependency>
             <dependency>
                 <groupId>io.helidon.integrations.common</groupId>
                 <artifactId>helidon-integrations-common-rest</artifactId>
diff --git a/dependencies/pom.xml b/dependencies/pom.xml
index 50416562383..c92a14f2f95 100644
--- a/dependencies/pom.xml
+++ b/dependencies/pom.xml
@@ -163,6 +163,7 @@
         <version.lib.zipkin.sender-urlconnection>2.16.4</version.lib.zipkin.sender-urlconnection>
         <version.lib.zipkin>2.12.5</version.lib.zipkin>
         <version.lib.zookeeper>3.5.7</version.lib.zookeeper>
+        <version.lib.crac>1.4.0</version.lib.crac>
     </properties>
 
     <dependencyManagement>
@@ -1092,6 +1093,11 @@
                 <artifactId>reactive-streams-tck</artifactId>
                 <version>${version.lib.reactivestreams}</version>
             </dependency>
+            <dependency>
+                <groupId>org.crac</groupId>
+                <artifactId>crac</artifactId>
+                <version>${version.lib.crac}</version>
+            </dependency>
             <!-- END OF Section 1: direct third party dependencies -->
 
             <!-- Section 2: third party dependencies used by examples -->
diff --git a/integrations/crac/pom.xml b/integrations/crac/pom.xml
new file mode 100644
index 00000000000..09847a2d89d
--- /dev/null
+++ b/integrations/crac/pom.xml
@@ -0,0 +1,45 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+
+    Copyright (c) 2025 Oracle and/or its affiliates.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+
+-->
+
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+        xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <parent>
+        <groupId>io.helidon.integrations</groupId>
+        <artifactId>helidon-integrations-project</artifactId>
+        <version>4.2.0-SNAPSHOT</version>
+    </parent>
+    <modelVersion>4.0.0</modelVersion>
+
+    <groupId>io.helidon.integrations.crac</groupId>
+    <artifactId>helidon-integrations-crac</artifactId>
+    <name>Helidon CRaC support</name>
+
+    <dependencies>
+        <dependency>
+            <groupId>io.helidon.webserver</groupId>
+            <artifactId>helidon-webserver</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.crac</groupId>
+            <artifactId>crac</artifactId>
+        </dependency>
+    </dependencies>
+
+</project>
\ No newline at end of file
diff --git a/integrations/crac/src/main/java/io/helidon/integrations/crac/CracImpl.java b/integrations/crac/src/main/java/io/helidon/integrations/crac/CracImpl.java
new file mode 100644
index 00000000000..8380fe66066
--- /dev/null
+++ b/integrations/crac/src/main/java/io/helidon/integrations/crac/CracImpl.java
@@ -0,0 +1,255 @@
+/*
+ * Copyright (c) 2025 Oracle and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.helidon.integrations.crac;
+
+import java.util.HashSet;
+import java.util.Set;
+
+import io.helidon.webserver.crac.spi.Crac;
+
+import org.crac.management.CRaCMXBean;
+
+/**
+ * Helidon abstraction over CRaC API, replaces no-op implementation when this module is present on classpath.
+ */
+public class CracImpl implements Crac {
+
+    private static final System.Logger LOGGER = System.getLogger(CracImpl.class.getName());
+    private static final Set<Object> STRONG_REFERENCES = new HashSet<>();
+
+    @Override
+    public io.helidon.webserver.crac.spi.Crac.Context<Resource> getGlobalContext() {
+        return new HelidonContext(org.crac.Core.getGlobalContext());
+    }
+
+    @Override
+    public long getUptimeSinceRestore() {
+        return CRaCMXBean.getCRaCMXBean().getUptimeSinceRestore();
+    }
+
+    @Override
+    public long getRestoreTime() {
+        return CRaCMXBean.getCRaCMXBean().getRestoreTime();
+    }
+
+    @Override
+    public void checkpointRestore() throws RestoreException, CheckpointException {
+        try {
+            org.crac.Core.checkpointRestore();
+        } catch (org.crac.RestoreException e) {
+            throw new HelidonRestoreException(e);
+        } catch (org.crac.CheckpointException e) {
+            throw new HelidonCheckpointException(e);
+        }
+    }
+
+    @Override
+    public void checkpointRestoreOnStartup() {
+        if ("onStart".equalsIgnoreCase(System.getProperty("io.helidon.crac.checkpoint"))) {
+            try {
+                org.crac.Core.checkpointRestore();
+            } catch (UnsupportedOperationException e) {
+                LOGGER.log(System.Logger.Level.DEBUG, "CRaC feature is not available", e);
+            } catch (org.crac.RestoreException e) {
+                LOGGER.log(System.Logger.Level.ERROR, "CRaC restore wasn't successful!", e);
+            } catch (org.crac.CheckpointException e) {
+                LOGGER.log(System.Logger.Level.ERROR, "CRaC checkpoint creation wasn't successful!", e);
+            }
+        }
+    }
+
+    private static class HelidonContext extends io.helidon.webserver.crac.spi.Crac.Context<Resource> {
+
+        private final org.crac.Context<org.crac.Resource> delegate;
+
+        HelidonContext(org.crac.Context<org.crac.Resource> delegate) {
+            this.delegate = delegate;
+        }
+
+        @SuppressWarnings("unchecked")
+        @Override
+        public void beforeCheckpoint(
+                io.helidon.webserver.crac.spi.Crac.Context<? extends io.helidon.webserver.crac.spi.Crac.Resource> context)
+                throws io.helidon.webserver.crac.spi.Crac.CheckpointException {
+            try {
+                delegate.beforeCheckpoint(new CracContext((Context<Resource>) context));
+            } catch (org.crac.CheckpointException e) {
+                throw new HelidonCheckpointException(e);
+            }
+        }
+
+        @SuppressWarnings("unchecked")
+        @Override
+        public void afterRestore(Context<? extends Resource> context) throws io.helidon.webserver.crac.spi.Crac.RestoreException {
+            try {
+                delegate.afterRestore(new CracContext((Context<Resource>) context));
+            } catch (org.crac.RestoreException e) {
+                throw new HelidonRestoreException(e);
+            }
+        }
+
+        @Override
+        public void register(Resource resource) {
+            CracResource resourceRef = new CracResource(resource);
+            // CRaC API keeps resources as weak refs, we don't want our wrappers being GCed
+            CracImpl.STRONG_REFERENCES.add(resourceRef);
+            delegate.register(resourceRef);
+        }
+
+    }
+
+    private static class HelidonCheckpointException extends io.helidon.webserver.crac.spi.Crac.CheckpointException {
+        private final org.crac.CheckpointException delegate;
+
+        HelidonCheckpointException(org.crac.CheckpointException delegate) {
+            this.delegate = delegate;
+            this.setStackTrace(delegate.getStackTrace());
+        }
+
+        @Override
+        public String getMessage() {
+            return delegate.getMessage();
+        }
+
+    }
+
+    private static class CracCheckpointException extends org.crac.CheckpointException {
+        private final io.helidon.webserver.crac.spi.Crac.CheckpointException delegate;
+
+        CracCheckpointException(io.helidon.webserver.crac.spi.Crac.CheckpointException delegate) {
+            this.delegate = delegate;
+            this.setStackTrace(delegate.getStackTrace());
+        }
+
+        @Override
+        public String getMessage() {
+            return delegate.getMessage();
+        }
+
+    }
+
+    private static class HelidonRestoreException extends io.helidon.webserver.crac.spi.Crac.RestoreException {
+        private final org.crac.RestoreException delegate;
+
+        HelidonRestoreException(org.crac.RestoreException delegate) {
+            this.delegate = delegate;
+            this.setStackTrace(delegate.getStackTrace());
+        }
+
+        @Override
+        public String getMessage() {
+            return delegate.getMessage();
+        }
+    }
+
+    private static class CracRestoreException extends org.crac.RestoreException {
+        private final io.helidon.webserver.crac.spi.Crac.RestoreException delegate;
+
+        CracRestoreException(io.helidon.webserver.crac.spi.Crac.RestoreException delegate) {
+            this.delegate = delegate;
+            this.setStackTrace(delegate.getStackTrace());
+        }
+
+        @Override
+        public String getMessage() {
+            return delegate.getMessage();
+        }
+    }
+
+    private static class CracContext extends org.crac.Context<org.crac.Resource> {
+
+        private final io.helidon.webserver.crac.spi.Crac.Context<io.helidon.webserver.crac.spi.Crac.Resource> delegate;
+
+        CracContext(io.helidon.webserver.crac.spi.Crac.Context<io.helidon.webserver.crac.spi.Crac.Resource> delegate) {
+            this.delegate = delegate;
+        }
+
+        @SuppressWarnings("unchecked")
+        @Override
+        public void beforeCheckpoint(org.crac.Context<? extends org.crac.Resource> context) throws org.crac.CheckpointException {
+            try {
+                delegate.beforeCheckpoint(new HelidonContext((org.crac.Context<org.crac.Resource>) context));
+            } catch (CheckpointException e) {
+                throw new CracCheckpointException(e);
+            }
+        }
+
+        @SuppressWarnings("unchecked")
+        @Override
+        public void afterRestore(org.crac.Context<? extends org.crac.Resource> context) throws org.crac.RestoreException {
+            try {
+                delegate.afterRestore(new HelidonContext((org.crac.Context<org.crac.Resource>) context));
+            } catch (RestoreException e) {
+                throw new CracRestoreException(e);
+            }
+        }
+
+        @Override
+        public void register(org.crac.Resource resource) {
+            delegate.register(new HelidonResource(resource));
+        }
+
+    }
+
+    private static class CracResource implements org.crac.Resource {
+
+        private final Resource delegate;
+
+        CracResource(Resource delegate) {
+            this.delegate = delegate;
+        }
+
+        @SuppressWarnings("unchecked")
+        @Override
+        public void beforeCheckpoint(org.crac.Context<? extends org.crac.Resource> context) throws Exception {
+            delegate.beforeCheckpoint(new HelidonContext((org.crac.Context<org.crac.Resource>) context));
+        }
+
+        @SuppressWarnings("unchecked")
+        @Override
+        public void afterRestore(org.crac.Context<? extends org.crac.Resource> context) throws Exception {
+            delegate.afterRestore(new HelidonContext((org.crac.Context<org.crac.Resource>) context));
+        }
+
+    }
+
+    private static class HelidonResource implements io.helidon.webserver.crac.spi.Crac.Resource {
+
+        private final org.crac.Resource delegate;
+
+        HelidonResource(org.crac.Resource delegate) {
+            this.delegate = delegate;
+        }
+
+        @SuppressWarnings("unchecked")
+        @Override
+        public void beforeCheckpoint(
+                io.helidon.webserver.crac.spi.Crac.Context<? extends io.helidon.webserver.crac.spi.Crac.Resource> context)
+                throws Exception {
+            delegate.beforeCheckpoint(new CracContext((Context<Resource>) context));
+        }
+
+        @SuppressWarnings("unchecked")
+        @Override
+        public void afterRestore(
+                io.helidon.webserver.crac.spi.Crac.Context<? extends io.helidon.webserver.crac.spi.Crac.Resource> context)
+                throws Exception {
+            delegate.afterRestore(new CracContext((Context<Resource>) context));
+        }
+
+    }
+}
diff --git a/integrations/crac/src/main/java/io/helidon/integrations/crac/package-info.java b/integrations/crac/src/main/java/io/helidon/integrations/crac/package-info.java
new file mode 100644
index 00000000000..66233d56f1d
--- /dev/null
+++ b/integrations/crac/src/main/java/io/helidon/integrations/crac/package-info.java
@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) 2025 Oracle and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Helidon abstraction over CRaC API, replaces no-op implementation when this module is present on classpath.
+ */
+package io.helidon.integrations.crac;
diff --git a/integrations/crac/src/main/java/module-info.java b/integrations/crac/src/main/java/module-info.java
new file mode 100644
index 00000000000..f9ee851120d
--- /dev/null
+++ b/integrations/crac/src/main/java/module-info.java
@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) 2025 Oracle and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+module io.helidon.integrations.crac {
+    requires crac;
+    requires io.helidon.webserver;
+    exports io.helidon.integrations.crac to io.helidon.webserver;
+    provides io.helidon.webserver.crac.spi.Crac with io.helidon.integrations.crac.CracImpl;
+}
\ No newline at end of file
diff --git a/integrations/pom.xml b/integrations/pom.xml
index a34e5d32a11..3697f4363ff 100644
--- a/integrations/pom.xml
+++ b/integrations/pom.xml
@@ -42,6 +42,7 @@
     <modules>
         <module>common</module>
         <module>cdi</module>
+        <module>crac</module>
         <module>graal</module>
         <module>db</module>
         <module>jdbc</module>
diff --git a/metrics/api/src/main/java/io/helidon/metrics/api/MetricsConfigBlueprint.java b/metrics/api/src/main/java/io/helidon/metrics/api/MetricsConfigBlueprint.java
index a93ac06e6fb..8e12313bbf6 100644
--- a/metrics/api/src/main/java/io/helidon/metrics/api/MetricsConfigBlueprint.java
+++ b/metrics/api/src/main/java/io/helidon/metrics/api/MetricsConfigBlueprint.java
@@ -205,7 +205,7 @@ static List<Tag> createTags(String pairs) {
      * @return true to include meters related to virtual threads
      */
     @Option.Configured("virtual-threads.enabled")
-    @Option.DefaultBoolean(true)
+    @Option.DefaultBoolean(false)
     boolean virtualThreadsEnabled();
 
     /**
diff --git a/microprofile/server/src/main/java/io/helidon/microprofile/server/ServerCdiExtension.java b/microprofile/server/src/main/java/io/helidon/microprofile/server/ServerCdiExtension.java
index 445b3065d1b..6378d705ca8 100644
--- a/microprofile/server/src/main/java/io/helidon/microprofile/server/ServerCdiExtension.java
+++ b/microprofile/server/src/main/java/io/helidon/microprofile/server/ServerCdiExtension.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018, 2024 Oracle and/or its affiliates.
+ * Copyright (c) 2018, 2025 Oracle and/or its affiliates.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -17,7 +17,6 @@
 package io.helidon.microprofile.server;
 
 import java.lang.System.Logger.Level;
-import java.lang.management.ManagementFactory;
 import java.lang.reflect.Field;
 import java.lang.reflect.Method;
 import java.nio.file.Path;
@@ -29,7 +28,6 @@
 import java.util.Map;
 import java.util.Optional;
 import java.util.Set;
-import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.function.Supplier;
@@ -49,6 +47,7 @@
 import io.helidon.webserver.WebServer;
 import io.helidon.webserver.WebServerConfig;
 import io.helidon.webserver.context.ContextFeature;
+import io.helidon.webserver.crac.spi.Crac;
 import io.helidon.webserver.http.HttpRouting;
 import io.helidon.webserver.http.HttpService;
 import io.helidon.webserver.http.ServerRequest;
@@ -80,10 +79,6 @@
 import jakarta.enterprise.inject.spi.ProcessProducerMethod;
 import jakarta.ws.rs.core.Application;
 import jakarta.ws.rs.ext.ParamConverterProvider;
-import org.crac.CheckpointException;
-import org.crac.Core;
-import org.crac.Resource;
-import org.crac.RestoreException;
 import org.eclipse.microprofile.config.ConfigProvider;
 import org.glassfish.jersey.internal.inject.Bindings;
 import org.glassfish.jersey.internal.inject.InjectionManager;
@@ -97,7 +92,7 @@
 /**
  * Extension to handle web server configuration and lifecycle.
  */
-public class ServerCdiExtension implements Extension, Resource {
+public class ServerCdiExtension implements Extension {
     private static final System.Logger LOGGER = System.getLogger(ServerCdiExtension.class.getName());
     private static final System.Logger STARTUP_LOGGER = System.getLogger("io.helidon.microprofile.startup.server");
     private static final AtomicBoolean IN_PROGRESS_OR_RUNNING = new AtomicBoolean();
@@ -125,10 +120,6 @@ public class ServerCdiExtension implements Extension, Resource {
 
     private Context context;
 
-    private long cracRestoreTime = -1;
-    private final CompletableFuture<org.crac.Context<? extends Resource>> restored = new CompletableFuture<>();
-
-
     /**
      * Default constructor required by {@link java.util.ServiceLoader}.
      */
@@ -470,18 +461,6 @@ private void startServer(@Observes @Priority(PLATFORM_AFTER + 100) @Initialized(
         }
         webserver = serverBuilder.build();
 
-        if ("onStart".equalsIgnoreCase(System.getProperty("io.helidon.crac.checkpoint"))) {
-            try {
-                Core.checkpointRestore();
-            } catch (UnsupportedOperationException e) {
-                LOGGER.log(Level.DEBUG, "CRaC feature is not available", e);
-            } catch (RestoreException e) {
-                LOGGER.log(Level.ERROR, "CRaC restore wasn't successful!", e);
-            } catch (CheckpointException e) {
-                LOGGER.log(Level.ERROR, "CRaC checkpoint creation wasn't successful!", e);
-            }
-        }
-
         try {
             webserver.start();
             started = true;
@@ -491,20 +470,16 @@ private void startServer(@Observes @Priority(PLATFORM_AFTER + 100) @Initialized(
 
         this.port = webserver.port();
 
-        long initializationElapsedTime = ManagementFactory.getRuntimeMXBean().getUptime();
+        Crac.get().checkpointRestoreOnStartup();
+        long initializationElapsedTime = Crac.get().getUptime();
 
         String protocol = "http" + (webserver.hasTls() ? "s" : "");
         String host = "0.0.0.0".equals(listenHost) ? "localhost" : listenHost;
         String note = "0.0.0.0".equals(listenHost) ? " (and all other host addresses)" : "";
 
-
-        String startupTimeReport = cracRestoreTime == -1
-                ? " in " + initializationElapsedTime + " milliseconds (since JVM startup). "
-                : " in " + (System.currentTimeMillis() - cracRestoreTime) + " milliseconds (since CRaC restore).";
-
         LOGGER.log(Level.INFO, () -> "Server started on "
                 + protocol + "://" + host + ":" + port
-                + note + startupTimeReport);
+                + note + " in " + initializationElapsedTime + " milliseconds (since JVM startup).");
 
         // this is not needed at runtime, collect garbage
         serverBuilder = null;
@@ -783,17 +758,4 @@ private HttpRouting.Builder findRouting(String className,
 
         return serverNamedRoutingBuilder(routingName);
     }
-
-    @Override
-    public void beforeCheckpoint(org.crac.Context<? extends Resource> context) throws Exception {
-        LOGGER.log(Level.INFO, "Creating CRaC snapshot after "
-                + ManagementFactory.getRuntimeMXBean().getUptime()
-                + "ms of runtime.");
-    }
-
-    @Override
-    public void afterRestore(org.crac.Context<? extends Resource> context) throws Exception {
-        cracRestoreTime = System.currentTimeMillis();
-        LOGGER.log(Level.INFO, "CRaC snapshot restored!");
-    }
 }
diff --git a/microprofile/server/src/main/java/module-info.java b/microprofile/server/src/main/java/module-info.java
index 161737fc3db..35f61eae80d 100644
--- a/microprofile/server/src/main/java/module-info.java
+++ b/microprofile/server/src/main/java/module-info.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018, 2024 Oracle and/or its affiliates.
+ * Copyright (c) 2018, 2025 Oracle and/or its affiliates.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/webserver/webserver/pom.xml b/webserver/webserver/pom.xml
index d20da117294..f7b2e4652d2 100644
--- a/webserver/webserver/pom.xml
+++ b/webserver/webserver/pom.xml
@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!--
-    Copyright (c) 2022, 2024 Oracle and/or its affiliates.
+    Copyright (c) 2022, 2025 Oracle and/or its affiliates.
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -92,11 +92,6 @@
             <groupId>io.helidon.config</groupId>
             <artifactId>helidon-config</artifactId>
         </dependency>
-        <dependency>
-            <groupId>org.crac</groupId>
-            <artifactId>crac</artifactId>
-            <version>1.4.0</version>
-        </dependency>
         <dependency>
             <groupId>io.helidon.config</groupId>
             <artifactId>helidon-config-yaml</artifactId>
diff --git a/webserver/webserver/src/main/java/io/helidon/webserver/LoomServer.java b/webserver/webserver/src/main/java/io/helidon/webserver/LoomServer.java
index b66cef82180..b99d5ba0525 100644
--- a/webserver/webserver/src/main/java/io/helidon/webserver/LoomServer.java
+++ b/webserver/webserver/src/main/java/io/helidon/webserver/LoomServer.java
@@ -16,7 +16,6 @@
 
 package io.helidon.webserver;
 
-import java.lang.management.ManagementFactory;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.LinkedList;
@@ -44,13 +43,11 @@
 import io.helidon.http.encoding.ContentEncodingContext;
 import io.helidon.http.media.MediaContext;
 import io.helidon.spi.HelidonShutdownHandler;
+import io.helidon.webserver.crac.spi.Crac;
 import io.helidon.webserver.http.DirectHandlers;
 import io.helidon.webserver.spi.ServerFeature;
 
-import org.crac.Core;
-import org.crac.Resource;
-
-class LoomServer implements WebServer, Resource {
+class LoomServer implements WebServer, Crac.Resource {
     private static final System.Logger LOGGER = System.getLogger(LoomServer.class.getName());
     private static final String EXIT_ON_STARTED_KEY = "exit.on.started";
     private static final AtomicInteger WEBSERVER_COUNTER = new AtomicInteger(1);
@@ -105,7 +102,7 @@ class LoomServer implements WebServer, Resource {
         });
 
         listeners = Map.copyOf(listenerMap);
-        Core.getGlobalContext().register(this);
+        Crac.register(this);
     }
 
     @Override
@@ -223,7 +220,8 @@ private void startIt() {
             registerShutdownHook();
         }
         now = System.currentTimeMillis() - now;
-        long uptime = ManagementFactory.getRuntimeMXBean().getUptime();
+        // JVM uptime or since restore
+        long uptime = Crac.get().getUptime();
 
         LOGGER.log(System.Logger.Level.INFO, "Started all channels in "
                 + now + " milliseconds. "
@@ -288,11 +286,11 @@ private boolean parallel(String taskName, Consumer<ServerListener> task) {
     }
 
     @Override
-    public void beforeCheckpoint(org.crac.Context<? extends Resource> context) throws Exception {
+    public void beforeCheckpoint(Crac.Context<? extends Crac.Resource> context) throws Exception {
         try {
             lifecycleLock.lockInterruptibly();
         } catch (InterruptedException e) {
-            throw new RuntimeException("Interrupted", e);
+            throw new RuntimeException("Interrupted during snapshot checkpoint.", e);
         }
         try {
             if (running.get()) {
@@ -306,11 +304,12 @@ public void beforeCheckpoint(org.crac.Context<? extends Resource> context) throw
     }
 
     @Override
-    public void afterRestore(org.crac.Context<? extends Resource> context) throws Exception {
+    public void afterRestore(Crac.Context<? extends Crac.Resource> context) throws Exception {
+        long now = System.currentTimeMillis();
         try {
             lifecycleLock.lockInterruptibly();
         } catch (InterruptedException e) {
-            throw new RuntimeException("Interrupted", e);
+            throw new RuntimeException("Interrupted during snapshot restore.", e);
         }
         try {
             if (running.get()) {
@@ -321,6 +320,11 @@ public void afterRestore(org.crac.Context<? extends Resource> context) throws Ex
         } finally {
             lifecycleLock.unlock();
         }
+        now = System.currentTimeMillis() - now;
+        LOGGER.log(System.Logger.Level.INFO, "Restored all channels in "
+                + now + " milliseconds. "
+                + Crac.get().getUptimeSinceRestore() + " milliseconds since JVM snapshot restore. "
+                + "Java " + Runtime.version());
     }
 
     private record ListenerFuture(ServerListener listener, Future<?> future) {
diff --git a/webserver/webserver/src/main/java/io/helidon/webserver/ServerListener.java b/webserver/webserver/src/main/java/io/helidon/webserver/ServerListener.java
index b742ad04380..39d3edb117d 100644
--- a/webserver/webserver/src/main/java/io/helidon/webserver/ServerListener.java
+++ b/webserver/webserver/src/main/java/io/helidon/webserver/ServerListener.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2022, 2024 Oracle and/or its affiliates.
+ * Copyright (c) 2022, 2025 Oracle and/or its affiliates.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -233,6 +233,8 @@ private void suspend(boolean shutdownExecutors) {
         try {
             // Stop listening for connections
             serverSocket.close();
+            // Close all active connections
+            activeConnections().forEach(connection -> connection.close(true));
 
             if (shutdownExecutors) {
                 // Shutdown reader executor
diff --git a/webserver/webserver/src/main/java/io/helidon/webserver/crac/spi/Crac.java b/webserver/webserver/src/main/java/io/helidon/webserver/crac/spi/Crac.java
new file mode 100644
index 00000000000..b20ee9685c7
--- /dev/null
+++ b/webserver/webserver/src/main/java/io/helidon/webserver/crac/spi/Crac.java
@@ -0,0 +1,214 @@
+/*
+ * Copyright (c) 2025 Oracle and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.helidon.webserver.crac.spi;
+
+import java.lang.management.ManagementFactory;
+import java.util.ServiceLoader;
+
+import io.helidon.common.LazyValue;
+
+/**
+ * Helidon abstraction over CRaC API, no-op when integration module is not on classpath.
+ */
+public interface Crac {
+
+    /**
+     * Lazy singleton instance, either abstraction over actual CRaC API or no-op if integration module
+     * is missing on classpath.
+     */
+    LazyValue<Crac> INSTANCE = LazyValue.create(() -> ServiceLoader.load(Crac.class)
+            .findFirst()
+            .orElseGet(CracNoop::new));
+
+    /**
+     * Gets CRaC singleton.
+     * @return singleton
+     */
+    static Crac get() {
+        return INSTANCE.get();
+    }
+
+    /**
+     * Registers a {@code Resource} with Global {@code Context}.
+     *
+     * @param resource {@code Resource} to be registered.
+     * @throws NullPointerException if {@code resource} is {@code null}
+     */
+    static void register(Resource resource) {
+        get().getGlobalContext().register(resource);
+    }
+
+    /**
+     * Requests checkpoint and returns upon a successful restore.
+     * May throw an exception if the checkpoint or restore are unsuccessful.
+     *
+     * @throws CheckpointException           if an exception occurred during checkpoint
+     *                                       notification and the execution continues in the original Java instance.
+     * @throws RestoreException              if an exception occurred during restore
+     *                                       notification and execution continues in a new Java instance.
+     * @throws UnsupportedOperationException if checkpoint/restore is not
+     *                                       supported, no notification performed and the execution continues in
+     *                                       the original Java instance.
+     */
+    void checkpointRestore() throws RestoreException, CheckpointException;
+
+    /**
+     * Requests checkpoint and returns upon a successful restore when {@code -Dio.helidon.crac.checkpoint=onStartup} is set.
+     */
+    void checkpointRestoreOnStartup();
+
+    /**
+     * Returns CRaC API global context abstraction.
+     * @return global context
+     */
+    Context<Resource> getGlobalContext();
+
+    /**
+     * Returns the time since the Java virtual machine restore was initiated.
+     * If the machine was not restored, returns -1.
+     *
+     * @return uptime of the Java virtual machine in milliseconds.
+     * @see java.lang.management.RuntimeMXBean#getStartTime()
+     */
+    long getUptimeSinceRestore();
+
+    /**
+     * Returns the time when the Java virtual machine restore was initiated.
+     * The value is the number of milliseconds since the start of the epoch.
+     * If the machine was not restored, returns -1.
+     *
+     * @return start time of the Java virtual machine in milliseconds.
+     * @see java.lang.management.RuntimeMXBean#getUptime()
+     */
+    long getRestoreTime();
+
+    /**
+     * Returns either uptime since restore, or since JVM start if not restored.
+     * @return actual uptime in milliseconds
+     */
+    default long getUptime() {
+        long uptimeSinceRestore = getUptimeSinceRestore();
+        return uptimeSinceRestore == -1 ? ManagementFactory.getRuntimeMXBean().getUptime() : uptimeSinceRestore;
+    }
+
+    /**
+     * An interface for receiving checkpoint/restore notifications.
+     *
+     * <p>The class that is interested in receiving a checkpoint/restore notification
+     * implements this interface, and the object created with that class is
+     * registered with a {@code Context}, using {@code register} method.
+     */
+    interface Resource {
+
+        /**
+         * Invoked by a {@code Context} as a notification about checkpoint.
+         *
+         * @param context {@code Context} providing notification
+         * @throws Exception if the method have failed
+         */
+        void beforeCheckpoint(Context<? extends Resource> context) throws Exception;
+
+        /**
+         * Invoked by a {@code Context} as a notification about restore.
+         *
+         * @param context {@code Context} providing notification
+         * @throws Exception if the method have failed
+         */
+        void afterRestore(Context<? extends Resource> context) throws Exception;
+    }
+
+    /**
+     * A {@code Resource} that allows other {@code Resource}s to be registered with it.
+     *
+     * <p>{@code Context} implementation overrides {@code beforeCheckpoint} and {@code afterRestore}, defining how the
+     * notification about checkpoint and restore will be distributed by the {@code Context} hierarchy.
+     *
+     * <p>A {@code Context} implementor is encouraged to respect properties of the global {@code Context}.
+     *
+     * @param <R> Resource type
+     */
+    abstract class Context<R extends Resource> implements Resource {
+
+        /**
+         * Creates a {@code Context}.
+         */
+        protected Context() {
+        }
+
+        @Override
+        public abstract void beforeCheckpoint(Context<? extends Resource> context)
+                throws CheckpointException;
+
+        @Override
+        public abstract void afterRestore(Context<? extends Resource> context)
+                throws RestoreException;
+
+        /**
+         * Registers a {@code Resource} with this {@code Context}.
+         *
+         * @param resource {@code Resource} to be registered.
+         * @throws NullPointerException if {@code resource} is {@code null}
+         */
+        public abstract void register(R resource);
+    }
+
+    /**
+     * Suppresses exceptions thrown during checkpoint notification.
+     */
+    class CheckpointException extends Exception {
+
+        /**
+         * Creates a {@code CheckpointException}.
+         */
+        public CheckpointException() {
+            super();
+        }
+
+        /**
+         * Constructs a {@code CheckpointException} with the specified
+         * detail message.
+         *
+         * @param message the detail message.
+         */
+        public CheckpointException(String message) {
+            super(message);
+        }
+    }
+
+    /**
+     * Suppresses exceptions thrown during restore notification.
+     */
+    class RestoreException extends Exception {
+
+        /**
+         * Creates a {@code RestoreException}.
+         */
+        public RestoreException() {
+            super();
+        }
+
+        /**
+         * Constructs a {@code RestoreException} with the specified
+         * detail message.
+         *
+         * @param message the detail message.
+         */
+        public RestoreException(String message) {
+            super(message);
+        }
+    }
+}
diff --git a/webserver/webserver/src/main/java/io/helidon/webserver/crac/spi/CracNoop.java b/webserver/webserver/src/main/java/io/helidon/webserver/crac/spi/CracNoop.java
new file mode 100644
index 00000000000..23d2f4e5c23
--- /dev/null
+++ b/webserver/webserver/src/main/java/io/helidon/webserver/crac/spi/CracNoop.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) 2024, 2025 Oracle and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.helidon.webserver.crac.spi;
+
+class CracNoop implements Crac {
+    @Override
+    public void checkpointRestore() {
+
+    }
+
+    @Override
+    public void checkpointRestoreOnStartup() {
+
+    }
+
+    @Override
+    public Context<Resource> getGlobalContext() {
+        return new Context<>() {
+
+            @Override
+            public void beforeCheckpoint(Context<? extends Resource> context) throws CheckpointException {
+
+            }
+
+            @Override
+            public void afterRestore(Context<? extends Resource> context) throws RestoreException {
+
+            }
+
+            @Override
+            public void register(Resource resource) {
+
+            }
+        };
+    }
+
+    @Override
+    public long getUptimeSinceRestore() {
+        return -1;
+    }
+
+    @Override
+    public long getRestoreTime() {
+        return -1;
+    }
+}
diff --git a/webserver/webserver/src/main/java/io/helidon/webserver/crac/spi/package-info.java b/webserver/webserver/src/main/java/io/helidon/webserver/crac/spi/package-info.java
new file mode 100644
index 00000000000..a67701936a2
--- /dev/null
+++ b/webserver/webserver/src/main/java/io/helidon/webserver/crac/spi/package-info.java
@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) 2025 Oracle and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Helidon abstraction over CRaC API, no-op when integration module is not on classpath.
+ */
+package io.helidon.webserver.crac.spi;
diff --git a/webserver/webserver/src/main/java/module-info.java b/webserver/webserver/src/main/java/module-info.java
index 1adb7c2adc5..d2025ccbd8a 100644
--- a/webserver/webserver/src/main/java/module-info.java
+++ b/webserver/webserver/src/main/java/module-info.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2022, 2024 Oracle and/or its affiliates.
+ * Copyright (c) 2022, 2025 Oracle and/or its affiliates.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -34,7 +34,6 @@
     requires io.helidon.logging.common;
     requires java.management;
     requires io.helidon;
-    requires crac;
 
     requires transitive io.helidon.common.buffers;
     requires transitive io.helidon.common.context;
@@ -56,6 +55,7 @@
     exports io.helidon.webserver.http.spi;
     exports io.helidon.webserver.http1;
     exports io.helidon.webserver.http1.spi;
+    exports io.helidon.webserver.crac.spi to io.helidon.integrations.crac, io.helidon.microprofile.server;
 
     uses io.helidon.webserver.spi.ServerConnectionSelectorProvider;
     uses io.helidon.webserver.spi.ProtocolConfigProvider;
@@ -63,6 +63,7 @@
     uses io.helidon.webserver.http.spi.SinkProvider;
     uses io.helidon.webserver.http1.spi.Http1UpgradeProvider;
     uses io.helidon.common.concurrency.limits.spi.LimitProvider;
+    uses io.helidon.webserver.crac.spi.Crac;
 
     provides io.helidon.webserver.spi.ProtocolConfigProvider
             with io.helidon.webserver.http1.Http1ProtocolConfigProvider;