diff --git a/src/TopoMojo.Api/Features/Admin/AdminController.cs b/src/TopoMojo.Api/Features/Admin/AdminController.cs
index ef84f83..b694677 100644
--- a/src/TopoMojo.Api/Features/Admin/AdminController.cs
+++ b/src/TopoMojo.Api/Features/Admin/AdminController.cs
@@ -84,8 +84,8 @@ public async Task<ActionResult<string[]>> ImportWorkspaces()
     public async Task<ActionResult> DownloadWorkspaces([FromBody] string[] ids)
     {
         string srcPath = fileUploadOptions.TopoRoot;
-        (var byteArray, var fileName) = await transferSvc.Download(ids, srcPath);
-        return File(byteArray, "application/zip", fileName);
+        var stream = await transferSvc.Download(ids, srcPath);
+        return File(stream, "application/zip", "topomojo-export.zip");
     }
 
     /// <summary>
diff --git a/src/TopoMojo.Api/Features/Admin/TransferService.cs b/src/TopoMojo.Api/Features/Admin/TransferService.cs
index b732512..3284f91 100644
--- a/src/TopoMojo.Api/Features/Admin/TransferService.cs
+++ b/src/TopoMojo.Api/Features/Admin/TransferService.cs
@@ -1,534 +1,329 @@
 // Copyright 2021 Carnegie Mellon University. All Rights Reserved.
 // Released under a 3 Clause BSD-style license. See LICENSE.md in the project root for license information.
 
-using System;
-using System.Collections.Generic;
-using System.IO;
 using System.IO.Compression;
-using System.Linq;
 using System.Text;
 using System.Text.Json;
-using System.Threading.Tasks;
 using AutoMapper;
-using Microsoft.AspNetCore.Http;
-using Microsoft.Extensions.Logging;
+using Microsoft.EntityFrameworkCore;
+using TopoMojo.Api.Data;
 using TopoMojo.Api.Data.Abstractions;
 using TopoMojo.Api.Extensions;
 
-namespace TopoMojo.Api.Services
+namespace TopoMojo.Api.Services;
+
+public class TransferService(
+    IWorkspaceStore workspaceStore,
+    ITemplateStore templateStore,
+    ILogger<TransferService> logger,
+    IMapper mapper,
+    CoreOptions options
+    ) : _Service(logger, mapper, options)
 {
-    public class TransferService : _Service
+    private readonly JsonSerializerOptions jsonSerializerSettings = new()
     {
-        public TransferService (
-            IUserStore userStore,
-            IWorkspaceStore workspaceStore,
-            ITemplateStore templateStore,
-            ILogger<TransferService> logger,
-            IMapper mapper,
-            CoreOptions options
-        ) : base(logger, mapper, options)
-        {
-            _workspaceStore = workspaceStore;
-            _templateStore = templateStore;
-            _userStore = userStore;
-            jsonSerializerSettings = new JsonSerializerOptions
-            {
-                WriteIndented = true,
-                ReferenceHandler = System.Text.Json.Serialization.ReferenceHandler.Preserve
-            };
-        }
+        WriteIndented = true
+    };
+
+    public async Task<IEnumerable<string>> Import(string repoPath, string docPath)
+    {
+        List<string> results = [];
 
-        private readonly IUserStore _userStore;
-        private readonly IWorkspaceStore _workspaceStore;
-        private readonly ITemplateStore _templateStore;
-        private JsonSerializerOptions jsonSerializerSettings;
+        var files = Directory.GetFiles(repoPath, "*export.zip", SearchOption.TopDirectoryOnly);
 
-        public async Task Export(string[] ids, string src, string dest)
+        foreach (string file in files)
         {
-            var list = new List<Data.Workspace>();
+            results.AddRange(
+                await ProcessZipfile(File.OpenRead(file), docPath)
+            );
 
-            foreach (string id in ids)
-            {
-                var topo = await _workspaceStore.LoadWithParents(id);
+            File.Move(file, file + ".imported");
+        }
 
-                if (topo != null)
-                    list.Add(topo);
+        return results;
+    }
 
-            }
+    public async Task Export(string[] ids, string src, string dest)
+    {
+        string fn = DateTimeOffset.UtcNow.ToString("yyyyMMddHHmmss") + "_export.zip";
+        string path = Path.Combine(dest, fn);
+        using FileStream writer = File.Create(path);
+        await writer.CopyToAsync(
+            await Download(ids, src)
+        );
+    }
 
-            if (list.Count < 1)
-                return;
+    public async Task<Stream> Download(string[] ids, string src)
+    {
+        List<Workspace> list = [];
+        List<Template> stock = [];
+        List<string> allDisks = [];
 
-            string docSrc = Path.Combine(src, "_docs");
+        // check if ALL workspaces were requested
+        if (ids.Length == 1 && ids[0].Equals("all", StringComparison.CurrentCultureIgnoreCase))
+        {
+            ids = [.. workspaceStore.List().Select(w => w.Id)];
+        }
 
-            string docDest = Path.Combine(dest, "_docs");
+        // hydrate workspace list
+        foreach (string id in ids)
+        {
+            var topo = await workspaceStore.LoadWithParents(id);
+            if (topo != null)
+                list.Add(topo);
+        }
 
-            if (!Directory.Exists(dest))
-                Directory.CreateDirectory(dest);
+        // automatically include any parent template workspaces
+        string[] parentWorkspaces = list.SelectMany(t => t.Templates)
+            .Select(t => t.Parent?.WorkspaceId)
+            .Where(t => t is not null)
+            .Distinct()
+            .ToArray()
+        ;
 
-            if (!Directory.Exists(docDest))
-                Directory.CreateDirectory(docDest);
+        string[] parents = parentWorkspaces.Except(list.Select(w => w.Id)).ToArray();
 
-            foreach (var topo in list)
+        foreach (string id in parents)
+        {
+            var topo = await workspaceStore.LoadWithParents(id);
+            if (topo != null)
             {
-                string folder = Path.Combine(dest, topo.Id);
-
-                Directory.CreateDirectory(folder);
-
-                File.WriteAllText(
-                    Path.Combine(folder, "import.this"),
-                    "please import this workspace"
-                );
-
-                //export data
-                topo.Workers.Clear();
-
-                topo.Gamespaces.Clear();
-
-                // topo.Id = 0;
-
-                topo.ShareCode = "";
-
-                foreach (var template in topo.Templates)
+                // removed linked, non-stock, templates
+                foreach (Template t in topo.Templates.ToArray())
                 {
-                    // template.Id = 0;
-                    template.WorkspaceId = null;
-                    template.Workspace = null;
-                }
-
-                File.WriteAllText(
-                    Path.Combine(folder, "topo.json"),
-                    JsonSerializer.Serialize(topo, jsonSerializerSettings)
-                );
+                    // remove non-stock linked templates
+                    if (t.IsLinked) {
+                        topo.Templates.Remove(t);
+                        continue;
+                    }
 
-                //export doc
-                try
-                {
-                    CopyFile(
-                        Path.Combine(docSrc, topo.Id) + ".md",
-                        Path.Combine(docDest, topo.Id) + ".md"
-                    );
+                    // remove historical parent from unlinked templates
+                    t.ParentId = null;
+                }
+                list.Add(topo);
+            }
+        }
 
-                    CopyFolder(
-                        Path.Combine(docSrc, topo.Id),
-                        Path.Combine(docDest, topo.Id)
-                    );
+        // automatically include referenced stock templates
+        var stock_ids = list.SelectMany(w => w.Templates)
+            .Where(t => t.Parent is not null && t.Parent?.Workspace is null)
+            .Select(t => t.ParentId)
+            .Distinct()
+            .ToArray()
+        ;
+
+        foreach (var id in stock_ids) {
+            var t = await templateStore.Retrieve(id);
+            if (t is not null)
+                stock.Add(t);
+        }
 
-                } catch {}
+        list.Add(new()
+            {
+                Id = Guid.Empty.ToString("n"),
+                Templates = stock
+            }
+        );
 
-                //export disk-list
-                var disks = new List<string>();
+        foreach (var topo in list)
+        {
+            // clean it up for export
+            topo.Workers.Clear();
+            topo.Gamespaces.Clear();
+            topo.ShareCode = "";
+            topo.LaunchCount = 0;
+            topo.LastActivity = DateTimeOffset.UtcNow;
+            foreach (var template in topo.Templates) {
+                template.Workspace = null;
+                template.Parent = null;
+            }
 
-                foreach (var template in topo.Templates)
-                {
+            // gather disk paths
+            List<string> disks = [];
+            foreach (var template in topo.Templates)
+            {
+                string detail = template.Detail ?? template.Parent?.Detail ?? null;
+                if (detail is not null) {
                     var tu = new TemplateUtility(template.Detail ?? template.Parent.Detail);
                     var t = tu.AsTemplate();
-
                     foreach (var disk in t.Disks)
                         disks.Add(disk.Path);
-
                     if (t.Iso.NotEmpty())
                         disks.Add(t.Iso);
                 }
-
-                if (disks.Count > 0)
-                {
-                    File.WriteAllLines(
-                        Path.Combine(folder, "topo.disks"),
-                        disks.Distinct()
-                    );
-                }
             }
 
+            allDisks.AddRange(disks);
         }
 
-        public async Task<Tuple<byte[], string>> Download(string[] ids, string src)
-        {
-            // check if ALL worspaces were requested
-            if (ids.Count() == 1 && ids[0].ToLower() == "all")
-            {
-                ids = _workspaceStore.List().Select(w => w.Id).ToArray();
-            }
-            using MemoryStream zipStream = new MemoryStream();
-            using (ZipArchive zipArchive = new ZipArchive(zipStream, ZipArchiveMode.Create, true))
-            {
-                // Add files to the zip archive
-                var list = new List<Data.Workspace>();
-
-                foreach (string id in ids)
-                {
-                    var topo = await _workspaceStore.LoadWithParents(id);
-                    if (topo != null)
-                        list.Add(topo);
-                }
-
-                if (list.Count < 1)
-                    return System.Tuple.Create(zipStream.ToArray(), "empty.zip");
+        list.Reverse();
 
-                string dest = "_export";
-                string docSrc = Path.Combine(src, "docs");
-                string docDest = Path.Combine(src, "_docs");
+        return await CreateZipfile(
+            list,
+            allDisks.Distinct(),
+            Path.Combine(src, "docs")
+        );
 
-                foreach (var topo in list)
-                {
-                    // set destination folder i.e. _export/4e49177c4c684f5088d12d702bbb0d46
-                    string folderInArchive = Path.Combine(dest, topo.Id);
-
-                    //write data
-                    topo.Workers.Clear();
-                    topo.Gamespaces.Clear();
-                    topo.ShareCode = "";
-                    foreach (var template in topo.Templates)
-                    {
-                        template.WorkspaceId = null;
-                        template.Workspace = null;
-                    }
-                    WriteFileToArchive(
-                        zipArchive,
-                        Path.Combine(folderInArchive, "topo.json"),
-                        Encoding.UTF8.GetBytes(JsonSerializer.Serialize(topo, jsonSerializerSettings)));
-
-                    //write disk-list
-                    var disks = new List<string>();
-                    foreach (var template in topo.Templates)
-                    {
-                        var tu = new TemplateUtility(template.Detail ?? template.Parent.Detail);
-                        var t = tu.AsTemplate();
-                        foreach (var disk in t.Disks)
-                            disks.Add(disk.Path);
-
-                        if (t.Iso.NotEmpty())
-                            disks.Add(t.Iso);
-                    }
-
-                    if (disks.Count > 0)
-                    {
-                        WriteFileToArchive(
-                            zipArchive,
-                            Path.Combine(folderInArchive, "topo.disks"),
-                            Encoding.UTF8.GetBytes(string.Join("\n", disks.Distinct()))
-                        );
-                    }
+    }
 
-                    //write doc
-                    try
-                    {
-                        string filePath = Path.Combine(docSrc, topo.Id) + ".md";
-                        if (File.Exists(filePath))
-                        {
-                            byte[] byteArray = new byte[(int)new FileInfo(filePath).Length];
-                            using (FileStream fileStream = new FileStream(filePath, FileMode.Open, FileAccess.Read))
-                            {
-                                fileStream.Read(byteArray, 0, byteArray.Length);
-                            }
-                            // set destination folder i.e. _export/_docs
-                            folderInArchive = Path.Combine(dest, "_docs");
-                            WriteFileToArchive(
-                                zipArchive,
-                                Path.Combine(folderInArchive, Path.GetFileName(filePath)),
-                                byteArray);
-                            //write supporting files
-                            filePath = Path.Combine(docSrc, topo.Id);
-                            string[] docFiles = Directory.GetFiles(filePath, "*", SearchOption.TopDirectoryOnly);
-                            // set destination folder i.e. _export/_docs/4e49177c4c684f5088d12d702bbb0d46
-                            folderInArchive = Path.Combine(folderInArchive, topo.Id);
-                            foreach (var docFile in docFiles)
-                            {
-                                byteArray = new byte[(int)new FileInfo(docFile).Length];
-                                using (FileStream fileStream = new FileStream(docFile, FileMode.Open, FileAccess.Read))
-                                {
-                                    fileStream.Read(byteArray, 0, byteArray.Length);
-                                }
-                                WriteFileToArchive(
-                                    zipArchive,
-                                    Path.Combine(folderInArchive, Path.GetFileName(docFile)),
-                                    byteArray);
-                            }
-                        }
-                    }
-                    catch { }
-                }
-            }
-            zipStream.Position = 0;
-            return System.Tuple.Create(zipStream.ToArray(), "topo-result-workspaces.zip");
-        }
+    public async Task<IEnumerable<string>> Upload(List<IFormFile> forms, string docPath)
+    {
+        string[] results = [];
 
-        public async Task<IEnumerable<string>> Import(string repoPath, string docPath)
+        foreach (var file in forms)
         {
-
-            var results = new List<string>();
-
-            var files = Directory.GetFiles(repoPath, "import.this", SearchOption.AllDirectories);
-
-            foreach (string file in files)
+            if (Path.GetExtension(file.FileName).Equals(".zip", StringComparison.CurrentCultureIgnoreCase))
             {
-                //skip any staged exports
-                if (file.Contains("_export"))
-                    continue;
-
-                try
-                {
-                    _logger.LogInformation("Importing topo from {0}", file);
+                results = await ProcessZipfile(file.OpenReadStream(), docPath);
+                continue;
+            }
 
-                    string folder = Path.GetDirectoryName(file);
+            if (file.FileName.Equals("_disks.txt"))
+                continue;
 
-                    //import data
-                    string dataFile = Path.Combine(folder, "topo.json");
+            if (file.FileName.Equals("_data.json"))
+            {
+                results = await ImportSerializedWorkspaces(file.OpenReadStream());
+                continue;
+            }
 
-                    var topo = JsonSerializer.Deserialize<Data.Workspace>(
-                        File.ReadAllText(dataFile),
-                        jsonSerializerSettings
-                    );
+        }
 
-                    //enforce uniqueness :(
-                    var found = await _workspaceStore.Retrieve(topo.Id);
+        return results;
+    }
 
-                    if (found != null)
-                        continue;
-                        // throw new Exception("Duplicate GlobalId");
 
-                    // map parentid to new parentId
-                    foreach (var template in topo.Templates)
-                    {
-                        if (template.Parent != null)
-                        {
-                            var pt = await _templateStore.Retrieve(template.Parent.Id);
+    private static void WriteFileToArchive(ZipArchive archive, string entryName, byte[] contentBytes)
+    {
+        ZipArchiveEntry entry = archive.CreateEntry(entryName);
+        using var entryStream = entry.Open();
+        entryStream.Write(contentBytes, 0, contentBytes.Length);
+    }
 
-                            if (pt == null)
-                            {
-                                template.ParentId = null;
-                                template.WorkspaceId = null;
-                                pt = await _templateStore.Create(template.Parent);
-                            }
+    private async Task<string[]> ImportSerializedWorkspaces(Stream stream)
+    {
+        using StreamReader reader = new(stream, Encoding.UTF8);
 
-                            template.ParentId = pt.Id;
-                            template.Parent = null;
-                        }
-                    }
+        var data = JsonSerializer.Deserialize<Workspace[]>(
+            await reader.ReadToEndAsync(),
+            jsonSerializerSettings
+        );
 
-                    await _workspaceStore.Create(topo);
+        return [.. (await ImportWorkspaces(data))];
+    }
 
-                    results.Add($"Success: {topo.Name}");
+    private async Task<string[]> ImportWorkspaces(IEnumerable<Workspace> data)
+    {
+        List<string> results = [];
+        var tids = await templateStore.List().Select(m => m.Id).ToArrayAsync();
+        var wids = await workspaceStore.List().Select(m => m.Id).ToArrayAsync();
 
-                }
-                catch (Exception ex)
-                {
-                    results.Add($"Failure: {file} -- {ex.Message}");
+        foreach(var topo in data)
+        {
+            // prevent overwriting
+            if (wids.Contains(topo.Id)) {
+                results.Add($"Duplicate: {topo.Name} {topo.Id}");
+                continue;
+            }
 
-                    _logger.LogError(ex, "Import topo failed for {0}", file);
-                }
-                finally
-                {
-                    //clean up
-                    File.Delete(file);
-                }
+            // add new stock templates
+            if (Guid.Parse(topo.Id) == Guid.Empty) {
+                var stock = topo.Templates.Where(t => !tids.Contains(t.Id)).ToArray();
+                workspaceStore.DbContext.Templates.AddRange(stock);
+                results.Add($"Stock templates: {stock.Length}");
+                continue;
             }
 
-            return results;
+            // add workspace to datacontext
+            workspaceStore.DbContext.Workspaces.Add(topo);
+            results.Add($"Success: {topo.Name} {topo.Id}");
         }
 
-        public async Task<IEnumerable<string>> Upload(List<IFormFile> forms, string docPath)
+        await workspaceStore.DbContext.SaveChangesAsync();
+        return [.. results];
+    }
+
+    private async Task<Stream> CreateZipfile(IEnumerable<Workspace> data, IEnumerable<string> disks, string docPath)
+    {
+        // write to zip in memory
+        MemoryStream zipStream = new();
+        using (ZipArchive zipArchive = new(zipStream, ZipArchiveMode.Create, true))
         {
-            // if a single zip file, extract all of the files contained in it
-            if (forms.Count == 1 && forms[0].FileName.ToLower().EndsWith(".zip"))
-            {
-                forms = ExtractFilesFromZip(forms[0]);
-            }
-            var results = new List<string>();
-            var files = forms.Where(f => f.FileName.EndsWith("topo.json"));
-            var newWorkspaces = new List<Data.Workspace>();
-            var newTemplates = new List<Data.Template>();
-            var existingTemplateIds = _templateStore.List().Select(m => m.Id).ToList();
-            var existingWorkspaceIds = _workspaceStore.List().Select(m => m.Id).ToList();
-            //create the workspaces
-            foreach (IFormFile file in files)
+            WriteFileToArchive(
+                zipArchive,
+                "_data.json",
+                Encoding.UTF8.GetBytes(JsonSerializer.Serialize(data, jsonSerializerSettings))
+            );
+
+            WriteFileToArchive(
+                zipArchive,
+                "_disks.txt",
+                Encoding.UTF8.GetBytes(string.Join("\n", disks))
+            );
+
+            // export markdown doc artifacts
+            try
             {
-                try
+                foreach (var topo in data)
                 {
-                    var topoJson = "";
-                    using (StreamReader reader = new StreamReader(file.OpenReadStream()))
+                    string filePath = Path.Combine(docPath, topo.Id);
+                    if (File.Exists(filePath + ".md"))
                     {
-                        // convert stream to string
-                        topoJson = reader.ReadToEnd();
-                    }
-                    var topo = JsonSerializer.Deserialize<Data.Workspace>(topoJson, jsonSerializerSettings);
-                    var topoId = topo.Id.Trim();
-                    _logger.LogInformation("Importing topo from {0}", file.FileName);
-
-                    //enforce uniqueness :(
-                    var found = await _workspaceStore.Retrieve(topoId);
-
-                    if (found != null)
-                        continue;
-
-                    // get list of new templates
-                    foreach (var template in topo.Templates)
-                    {
-                        // recursively add templates and parents
-                        var addedTemplates = AddTemplate(template);
-                        foreach (var tmp in addedTemplates)
-                        {
-                            if (!existingTemplateIds.Contains(tmp.Id))
-                            {
-                                tmp.Parent = null;
-                                tmp.Workspace = null;
-                                newTemplates.Add(tmp);
-                                existingTemplateIds.Add(tmp.Id);
-                            }
-                        }
-                    }
-                    topo.Templates.Clear();
-                    // get list of new workspaces
-                    if (!existingWorkspaceIds.Contains(topoId))
-                    {
-                        // if (topoId == "003aff045a0b4c58a9619e057343e80b")
-                        // {
-                        //     var x = 12;
-                        // }
-                        newWorkspaces.Add(topo);
-                        existingWorkspaceIds.Add(topoId);
-                    }
+                        WriteFileToArchive(
+                            zipArchive,
+                            topo.Id + ".md",
+                            await File.ReadAllBytesAsync(filePath + ".md")
+                        );
 
-                    // add the document
-                    var doc = forms.SingleOrDefault(f => f.FileName.EndsWith(topoId + ".md"));
-                    if (doc != null)
-                    {
-                        var path = Path.Combine(docPath, topoId + ".md");
-                        using (var stream = new FileStream(path, FileMode.Create))
+                        string[] docFiles = Directory.GetFiles(filePath, "*", SearchOption.TopDirectoryOnly);
+                        foreach (var docFile in docFiles)
                         {
-                            await doc.CopyToAsync(stream);
-                        }
-                        // add the supporting files
-                        var searchTerm = $"docs/{topoId}/";
-                        var supportingFiles = forms.Where(f => f.FileName.Contains(searchTerm));
-                        if (supportingFiles != null && supportingFiles.Count() > 0)
-                        {
-                            var supportPath = Path.Combine(docPath, topoId);
-                            if (!System.IO.Directory.Exists(supportPath))
-                                System.IO.Directory.CreateDirectory(supportPath);
-
-                            foreach (var supportingFile in supportingFiles)
-                            {
-                                int startIndex = supportingFile.FileName.IndexOf(searchTerm);
-                                if (startIndex != -1) // substring found
-                                {
-                                    int endIndex = startIndex + searchTerm.Length;
-                                    string filename = supportingFile.FileName.Substring(endIndex);
-                                    path = Path.Combine(supportPath, filename);
-                                    using (var stream = new FileStream(path, FileMode.Create))
-                                    {
-                                        await doc.CopyToAsync(stream);
-                                    }
-                                }
-                            }
+                            WriteFileToArchive(
+                                zipArchive,
+                                Path.Combine(topo.Id, Path.GetFileName(docFile)),
+                                await File.ReadAllBytesAsync(docFile)
+                            );
                         }
                     }
-
-                    // add success message to the results
-                    results.Add($"Success: {topo.Name}");
-
-                }
-                catch (Exception ex)
-                {
-                    results.Add($"Failure: {file} -- {ex.Message}");
-
-                    _logger.LogError(ex, "Import topo failed for {0}", file);
                 }
             }
-
-            //add the new workspaces
-            if (newWorkspaces.Count() > 0)
-            {
-                await _workspaceStore.Create(newWorkspaces);
-            }
-
-            //add the new templates
-            if (newTemplates.Count() > 0)
-            {
-                await _templateStore.Create(newTemplates);
-            }
-
-            return results;
-        }
-
-        private List<Data.Template> AddTemplate(Data.Template template)
-        {
-            var addedTemplates = new List<Data.Template>();
-            if (template.Parent == null)
-            {
-                addedTemplates.Add(template);
-            }
-            else
-            {
-                addedTemplates.AddRange(AddTemplate(template.Parent));
-            }
-
-            return addedTemplates;
+            catch { }
         }
 
-        private void CopyFile(string src, string dest, bool deleteSource = false)
-        {
-            if (File.Exists(src))
-            {
-                if (!Directory.Exists(Path.GetDirectoryName(dest)))
-                    Directory.CreateDirectory(Path.GetDirectoryName(dest));
-
-                File.Copy(src, dest);
+        zipStream.Position = 0;
+        return zipStream;
+    }
 
-                if (deleteSource)
-                    File.Delete(src);
-            }
-        }
+    private async Task<string[]> ProcessZipfile(Stream stream, string docPath)
+    {
+        string[] results = [];
+        using var zipArchive = new ZipArchive(stream, ZipArchiveMode.Read);
 
-        private void CopyFolder(string src, string dest, bool deleteSource = false)
+        // Iterate through the entries in the ZIP archive
+        foreach (var entry in zipArchive.Entries)
         {
-            if (Directory.Exists(src))
-            {
-                if (!Directory.Exists(dest))
-                    Directory.CreateDirectory(dest);
-
-                foreach (string file in Directory.GetFiles(src))
-                    File.Copy(file, Path.Combine(dest, Path.GetFileName(file)));
+            // skip disks
+            if (entry.FullName == "_disks.txt")
+                continue;
 
-                if (deleteSource)
-                    Directory.Delete(src, true);
-            }
-        }
-
-        private static void WriteFileToArchive(ZipArchive archive, string entryName, byte[] contentBytes)
-        {
-            // Create a new entry in the zip archive
-            ZipArchiveEntry entry = archive.CreateEntry(entryName);
-            // Write the content to the zip entry
-            using (var entryStream = entry.Open())
+            // deserialize workspace data
+            if (entry.FullName == "_data.json")
             {
-                entryStream.Write(contentBytes, 0, contentBytes.Length);
+                results = await ImportSerializedWorkspaces(entry.Open());
+                continue;
             }
-        }
-
-        private List<IFormFile> ExtractFilesFromZip(IFormFile zipFile)
-        {
-            var formFiles = new List<IFormFile>();
 
-            using (var zipArchiveStream = zipFile.OpenReadStream())
-            using (var zipArchive = new ZipArchive(zipArchiveStream, ZipArchiveMode.Read))
+            // save all other files to docs
+            if (!entry.FullName.EndsWith('/'))
             {
-                // Iterate through the entries in the ZIP archive
-                foreach (var entry in zipArchive.Entries)
-                {
-                    // Check if the entry is a file (not a directory)
-                    if (entry.Length > 0 && !entry.FullName.EndsWith("/"))
-                    {
-                        // Extract the file as an IFormFile
-                        var fileBytes = new byte[entry.Length];
-                        entry.Open().Read(fileBytes, 0, (int)entry.Length);
-                        var formFile = new FormFile(new MemoryStream(fileBytes), 0, entry.Length, entry.Name, entry.FullName);
-                        formFiles.Add(formFile);
-                    }
-                }
+                string dest = Path.Combine(docPath, entry.FullName);
+                Directory.CreateDirectory(Path.GetDirectoryName(dest));
+                using FileStream writer = File.Create(dest);
+                await entry.Open().CopyToAsync(writer);
             }
-            return formFiles;
         }
 
+        return results;
     }
+
 }