@stacksjs/cloud 0.58.43 → 0.58.45

package/dist/index.js

@@ -1,4 +1,15 @@
 // @bun
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
 // src/helpers.ts
 import {CloudFormation} from "@aws-sdk/client-cloudformation";
 import {CloudWatchLogsClient, DeleteLogGroupCommand, DescribeLogGroupsCommand} from "@aws-sdk/client-cloudwatch-logs";
@@ -477,361 +488,25 @@ class AiStack {
 import {Duration as Duration2, Fn, CfnOutput as Output2, aws_cloudfront as cloudfront, aws_cloudfront_origins as origins, aws_route53 as route53, aws_route53_targets as targets} from "aws-cdk-lib";
 import {config as config6} from "@stacksjs/config";
 
-// /Users/chrisbreuer/Code/stacks/storage/framework/core/storage/dist/index.js
+// /home/runner/work/stacks/stacks/storage/framework/core/storage/src/files.ts
 import {detectIndent, detectNewline} from "@stacksjs/strings";
 import {dirname, join as join2, path as p2} from "@stacksjs/path";
 
-// /Users/chrisbreuer/Code/stacks/storage/framework/core/arrays/dist/index.js
+// /home/runner/work/stacks/stacks/storage/framework/core/arrays/src/helpers.ts
 import {clamp} from "@stacksjs/utils";
-var toArray = function(array) {
-  array = array ?? [];
-  return Array.isArray(array) ? array : [array];
-};
-var flatten = function(array) {
-  return toArray(array).flat(1);
-};
-var mergeArrayable = function(...args) {
-  return args.flatMap((i) => toArray(i));
-};
-var partition = function(array, ...filters) {
-  const result = Array.from({ length: filters.length + 1 }).fill(null).map(() => []);
-  array.forEach((e, idx, arr) => {
-    let i = 0;
-    for (const filter of filters) {
-      if (filter(e, idx, arr)) {
-        result[i].push(e);
-        return;
-      }
-      i += 1;
-    }
-    result[i].push(e);
-  });
-  return result;
-};
-var uniq = function(array) {
-  return Array.from(new Set(array));
-};
-var unique = function(array) {
-  return uniq(array);
-};
-var uniqueBy = function(array, equalFn) {
-  return array.reduce((acc, cur) => {
-    const index = acc.findIndex((item) => equalFn(cur, item));
-    if (index === -1)
-      acc.push(cur);
-    return acc;
-  }, []);
-};
-var last = function(array) {
-  return at(array, -1);
-};
-var remove = function(array, value) {
-  if (!array)
-    return false;
-  const index = array.indexOf(value);
-  if (index >= 0) {
-    array.splice(index, 1);
-    return true;
-  }
-  return false;
-};
-var at = function(array, index) {
-  const len = array.length;
-  if (!len)
-    return;
-  if (index < 0)
-    index += len;
-  return array[index];
-};
-var move = function(array, from, to) {
-  const len = array.length;
-  if (!len)
-    return [];
-  if (from < 0)
-    from += len;
-  if (to < 0)
-    to += len;
-  const item = array.splice(from, 1)[0];
-  array.splice(to, 0, item);
-  return array;
-};
-var clampArrayRange = function(arr, n) {
-  return clamp(n, 0, arr.length - 1);
-};
-var sample = function(arr, count) {
-  return Array.from({ length: count }, (_) => arr[Math.round(Math.random() * (arr.length - 1))]);
-};
-var shuffle = function(array) {
-  for (let i = array.length - 1;i > 0; i--) {
-    const j = Math.floor(Math.random() * (i + 1));
-    [array[i], array[j]] = [array[j], array[i]];
-  }
-  return array;
-};
-var average = function(arr) {
-  return sum(arr) / arr.length;
-};
-var avg = function(arr) {
-  return average(arr);
-};
-var median = function(arr) {
-  return arr[Math.floor(arr.length / 2)];
-};
-var mode = function(arr) {
-  return arr.sort((a, b) => arr.filter((v) => v === a).length - arr.filter((v) => v === b).length).pop();
-};
-var sum = function(array) {
-  return array.reduce((acc, cur) => acc + cur, 0);
-};
-var product = function(array) {
-  return array.reduce((acc, cur) => acc * cur, 1);
-};
-var min = function(array) {
-  return Math.min(...array);
-};
-var max = function(array) {
-  return Math.max(...array);
-};
-var range = function(array) {
-  return max(array) - min(array);
-};
-var variance = function(array) {
-  const mean = average(array);
-  return average(array.map((num) => (num - mean) ** 2));
-};
-var standardDeviation = function(array) {
-  return Math.sqrt(variance(array));
-};
-var zScore = function(array, num) {
-  return (num - average(array)) / standardDeviation(array);
-};
-var percentile = function(array, num) {
-  return array.filter((n) => n < num).length / array.length;
-};
-var interquartileRange = function(array) {
-  const q1 = median(array.slice(0, Math.floor(array.length / 2)));
-  const q3 = median(array.slice(Math.ceil(array.length / 2)));
-  return q3 - q1;
-};
-var covariance = function(array1, array2) {
-  const mean1 = average(array1);
-  const mean2 = average(array2);
-  return average(array1.map((num1, i) => (num1 - mean1) * (array2[i] - mean2)));
-};
-var contains = function(needle, haystack) {
+// /home/runner/work/stacks/stacks/storage/framework/core/arrays/src/contains.ts
+function contains(needle, haystack) {
   return haystack.some((hay) => needle.includes(hay));
-};
-var containsAll = function(needles, haystack) {
-  return needles.every((needle) => contains(needle, haystack));
-};
-var containsAny = function(needles, haystack) {
-  return needles.some((needle) => contains(needle, haystack));
-};
-var containsNone = function(needles, haystack) {
-  return !containsAny(needles, haystack);
-};
-var containsOnly = function(needles, haystack) {
-  return containsAll(haystack, needles);
-};
-var doesNotContain = function(needle, haystack) {
-  return !contains(needle, haystack);
-};
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: (newValue) => all[name] = () => newValue
-    });
-};
-var exports_arr = {};
-__export(exports_arr, {
-  zScore: () => {
-    {
-      return zScore;
-    }
-  },
-  variance: () => {
-    {
-      return variance;
-    }
-  },
-  uniqueBy: () => {
-    {
-      return uniqueBy;
-    }
-  },
-  unique: () => {
-    {
-      return unique;
-    }
-  },
-  uniq: () => {
-    {
-      return uniq;
-    }
-  },
-  toArray: () => {
-    {
-      return toArray;
-    }
-  },
-  sum: () => {
-    {
-      return sum;
-    }
-  },
-  standardDeviation: () => {
-    {
-      return standardDeviation;
-    }
-  },
-  shuffle: () => {
-    {
-      return shuffle;
-    }
-  },
-  sample: () => {
-    {
-      return sample;
-    }
-  },
-  remove: () => {
-    {
-      return remove;
-    }
-  },
-  range: () => {
-    {
-      return range;
-    }
-  },
-  product: () => {
-    {
-      return product;
-    }
-  },
-  percentile: () => {
-    {
-      return percentile;
-    }
-  },
-  partition: () => {
-    {
-      return partition;
-    }
-  },
-  move: () => {
-    {
-      return move;
-    }
-  },
-  mode: () => {
-    {
-      return mode;
-    }
-  },
-  min: () => {
-    {
-      return min;
-    }
-  },
-  mergeArrayable: () => {
-    {
-      return mergeArrayable;
-    }
-  },
-  median: () => {
-    {
-      return median;
-    }
-  },
-  max: () => {
-    {
-      return max;
-    }
-  },
-  last: () => {
-    {
-      return last;
-    }
-  },
-  interquartileRange: () => {
-    {
-      return interquartileRange;
-    }
-  },
-  flatten: () => {
-    {
-      return flatten;
-    }
-  },
-  doesNotContain: () => {
-    {
-      return doesNotContain;
-    }
-  },
-  covariance: () => {
-    {
-      return covariance;
-    }
-  },
-  containsOnly: () => {
-    {
-      return containsOnly;
-    }
-  },
-  containsNone: () => {
-    {
-      return containsNone;
-    }
-  },
-  containsAny: () => {
-    {
-      return containsAny;
-    }
-  },
-  containsAll: () => {
-    {
-      return containsAll;
-    }
-  },
-  contains: () => {
-    {
-      return contains;
-    }
-  },
-  clampArrayRange: () => {
-    {
-      return clampArrayRange;
-    }
-  },
-  avg: () => {
-    {
-      return avg;
-    }
-  },
-  average: () => {
-    {
-      return average;
-    }
-  },
-  at: () => {
-    {
-      return at;
-    }
-  }
-});
-
-// /Users/chrisbreuer/Code/stacks/storage/framework/core/storage/dist/index.js
+}
+// /home/runner/work/stacks/stacks/storage/framework/core/storage/src/fs.ts
 import {mkdirSync, writeFileSync} from "fs";
 import * as fs from "fs-extra";
-import {pathExists as existsSync2} from "fs-extra";
-async function exists(path3) {
-  return await existsSync2(path3);
+import {pathExists as existsSync} from "fs-extra";
+async function exists(path2) {
+  return await existsSync(path2);
 }
+
+// /home/runner/work/stacks/stacks/storage/framework/core/storage/src/files.ts
 async function readJsonFile(name, cwd) {
   const file = await readTextFile(name, cwd);
   const data = JSON.parse(file.data);
@@ -843,14 +518,14 @@ async function readPackageJson(name, cwd) {
   const file = await readJsonFile(name, cwd);
   return file.data;
 }
-async function writeFile(path22, data) {
-  if (typeof path22 === "string") {
-    const dirPath = dirname(path22);
-    if (!await existsSync2(dirPath))
+async function writeFile(path3, data) {
+  if (typeof path3 === "string") {
+    const dirPath = dirname(path3);
+    if (!await existsSync(dirPath))
       await createFolder(dirPath);
-    return await Bun.write(Bun.file(path22), data);
+    return await Bun.write(Bun.file(path3), data);
   }
-  return await Bun.write(path22, data);
+  return await Bun.write(path3, data);
 }
 async function writeJsonFile(file) {
   let json = JSON.stringify(file.data, undefined, file.indent);
@@ -858,7 +533,7 @@ async function writeJsonFile(file) {
     json += file.newline;
   return writeTextFile({ ...file, data: json });
 }
-var readTextFile = function(name, cwd) {
+function readTextFile(name, cwd) {
   return new Promise((resolve, reject) => {
     let filePath;
     if (cwd)
@@ -876,48 +551,48 @@ var readTextFile = function(name, cwd) {
       }
     });
   });
-};
+}
 async function writeTextFile(file) {
   return await Bun.write(file.path, file.data);
 }
-var isFile = function(path22) {
-  return fs.existsSync(path22);
-};
-var doesExist = function(path22) {
-  return !isFile(path22) || !isFolder(path22);
-};
-var doesNotExist = function(path22) {
-  return !isFile(path22) && !isFolder(path22);
-};
-var hasFiles = function(folder) {
+function isFile(path3) {
+  return fs.existsSync(path3);
+}
+function doesExist(path3) {
+  return !isFile(path3) || !isFolder(path3);
+}
+function doesNotExist(path3) {
+  return !isFile(path3) && !isFolder(path3);
+}
+function hasFiles(folder) {
   try {
     return fs.readdirSync(folder).length > 0;
   } catch (err2) {
     return false;
   }
-};
-var hasComponents = function() {
+}
+function hasComponents() {
   return hasFiles(p2.componentsPath());
-};
-var hasFunctions = function() {
+}
+function hasFunctions() {
   return hasFiles(p2.functionsPath());
-};
-var deleteFiles = function(dir, exclude = []) {
+}
+function deleteFiles(dir, exclude = []) {
   if (fs.existsSync(dir)) {
     fs.readdirSync(dir).forEach((file) => {
-      const p22 = join2(dir, file);
-      if (fs.statSync(p22).isDirectory()) {
-        if (fs.readdirSync(p22).length === 0)
-          fs.rmSync(p22, { recursive: true, force: true });
+      const p3 = join2(dir, file);
+      if (fs.statSync(p3).isDirectory()) {
+        if (fs.readdirSync(p3).length === 0)
+          fs.rmSync(p3, { recursive: true, force: true });
         else
-          deleteFiles(p22, exclude);
-      } else if (!contains(p22, exclude)) {
-        fs.rmSync(p22);
+          deleteFiles(p3, exclude);
+      } else if (!contains(p3, exclude)) {
+        fs.rmSync(p3);
       }
     });
   }
-};
-var getFiles = function(dir, exclude = []) {
+}
+function getFiles(dir, exclude = []) {
   let results = [];
   const list = fs.readdirSync(dir);
   list.forEach((file) => {
@@ -929,34 +604,50 @@ var getFiles = function(dir, exclude = []) {
       results.push(file);
   });
   return results;
-};
-var put = function(path22, contents) {
-  const dirPath = dirname(path22);
+}
+function put(path3, contents) {
+  const dirPath = dirname(path3);
   if (!fs.existsSync(dirPath))
     fs.mkdirSync(dirPath, { recursive: true });
-  fs.writeFileSync(path22, contents, "utf-8");
-};
-async function get(path22) {
-  return Bun.file(path22).text();
+  fs.writeFileSync(path3, contents, "utf-8");
+}
+async function get(path3) {
+  return Bun.file(path3).text();
 }
+var files = {
+  readJsonFile,
+  readPackageJson,
+  readTextFile,
+  writeJsonFile,
+  writeTextFile,
+  isFile,
+  hasFiles,
+  hasComponents,
+  hasFunctions,
+  deleteFiles,
+  getFiles,
+  put,
+  get
+};
+// /home/runner/work/stacks/stacks/storage/framework/core/storage/src/folders.ts
 import {join as join3} from "@stacksjs/path";
-var isFolder2 = function(path32) {
+function isFolder2(path4) {
   try {
-    return fs.statSync(path32).isDirectory();
+    return fs.statSync(path4).isDirectory();
   } catch {
     return false;
   }
-};
-var isDirectory = function(path32) {
-  return isFolder2(path32);
-};
-var isDir = function(path32) {
-  return isFolder2(path32);
-};
-var doesFolderExist = function(path32) {
-  return fs.existsSync(path32);
-};
-var createFolder2 = function(dir) {
+}
+function isDirectory(path4) {
+  return isFolder2(path4);
+}
+function isDir(path4) {
+  return isFolder2(path4);
+}
+function doesFolderExist(path4) {
+  return fs.existsSync(path4);
+}
+function createFolder2(dir) {
   return new Promise((resolve, reject) => {
     fs.mkdirs(dir, (err2) => {
       if (err2)
@@ -965,17 +656,24 @@ var createFolder2 = function(dir) {
         resolve();
     });
   });
-};
-var getFolders = function(dir) {
+}
+function getFolders(dir) {
   return fs.readdirSync(dir).filter((file) => {
     return fs.statSync(join3(dir, file)).isDirectory();
   });
+}
+var folders = {
+  isFolder: isFolder2,
+  doesFolderExist,
+  createFolder: createFolder2,
+  getFolders
 };
-import {createHash} from "crypto";
-import {path as p22} from "@stacksjs/path";
+// /home/runner/work/stacks/stacks/storage/framework/core/storage/src/hash.ts
+import {path as p3} from "@stacksjs/path";
+// /home/runner/work/stacks/stacks/storage/framework/core/storage/src/helpers.ts
 import {fileURLToPath} from "url";
 import {dirname as dirname2} from "@stacksjs/path";
-var updateConfigFile = function(filePath, newConfig) {
+function updateConfigFile(filePath, newConfig) {
   return new Promise((resolve, reject) => {
     const config5 = JSON.parse(fs.readFileSync(filePath, "utf8"));
     for (const key in newConfig)
@@ -987,9 +685,16 @@ var updateConfigFile = function(filePath, newConfig) {
       reject(error);
     }
   });
+}
+var __dirname = "/home/runner/work/stacks/stacks/storage/framework/core/storage/src";
+var _dirname = typeof __dirname !== "undefined" ? __dirname : dirname2(fileURLToPath(import.meta.url));
+var helpers3 = {
+  _dirname,
+  updateConfigFile
 };
+// /home/runner/work/stacks/stacks/storage/framework/core/storage/src/copy.ts
 import {join as join4} from "@stacksjs/path";
-var copy = function(src, dest, exclude = []) {
+function copy(src, dest, exclude = []) {
   if (Array.isArray(src)) {
     src.forEach((file) => {
       copy(file, dest, exclude);
@@ -1000,11 +705,11 @@ var copy = function(src, dest, exclude = []) {
     else
       copyFile(src, dest);
   }
-};
-var copyFile = function(src, dest) {
+}
+function copyFile(src, dest) {
   fs.copyFileSync(src, dest);
-};
-var copyFolder = function(src, dest, exclude = []) {
+}
+function copyFolder(src, dest, exclude = []) {
   if (!fs.existsSync(dest))
     fs.mkdirSync(dest, { recursive: true });
   if (fs.existsSync(src)) {
@@ -1019,28 +724,30 @@ var copyFolder = function(src, dest, exclude = []) {
       }
     });
   }
-};
+}
+// /home/runner/work/stacks/stacks/storage/framework/core/storage/src/glob.ts
 import {default as default2} from "fast-glob";
+// /home/runner/work/stacks/stacks/storage/framework/core/storage/src/delete.ts
 import {err as err2, ok as ok2} from "@stacksjs/error-handling";
 import {italic, log as log2} from "@stacksjs/cli";
-var deleteFolder = function(path62) {
+function deleteFolder(path7) {
   return new Promise((resolve, reject) => {
     try {
-      if (isFolder2(path62)) {
-        fs.rmSync(path62, { recursive: true, force: true });
-        return resolve(ok2(`Deleted ${path62}`));
+      if (isFolder2(path7)) {
+        fs.rmSync(path7, { recursive: true, force: true });
+        return resolve(ok2(`Deleted ${path7}`));
       }
-      return resolve(ok2(`Path ${path62} was not a directory`));
+      return resolve(ok2(`Path ${path7} was not a directory`));
     } catch (error) {
       return reject(err2(error));
     }
   });
-};
-async function isDirectoryEmpty(path62) {
+}
+async function isDirectoryEmpty(path7) {
   return new Promise((resolve, reject) => {
     try {
-      if (fs.statSync(path62).isDirectory()) {
-        if (fs.readdirSync(path62).length === 0)
+      if (fs.statSync(path7).isDirectory()) {
+        if (fs.readdirSync(path7).length === 0)
           return resolve(ok2(true));
         else
           return resolve(ok2(false));
@@ -1051,18 +758,18 @@ async function isDirectoryEmpty(path62) {
     }
   });
 }
-async function deleteEmptyFolder(path62) {
+async function deleteEmptyFolder(path7) {
   return new Promise((resolve, reject) => {
     try {
-      if (fs.statSync(path62).isDirectory()) {
-        if (fs.readdirSync(path62).length === 0) {
-          fs.rmSync(path62, { recursive: true, force: true });
-          return resolve(ok2(`Deleted ${path62}`));
+      if (fs.statSync(path7).isDirectory()) {
+        if (fs.readdirSync(path7).length === 0) {
+          fs.rmSync(path7, { recursive: true, force: true });
+          return resolve(ok2(`Deleted ${path7}`));
         } else {
-          return resolve(ok2(`Path ${path62} was not empty`));
+          return resolve(ok2(`Path ${path7} was not empty`));
         }
       }
-      return resolve(ok2(`Path ${path62} was not a directory`));
+      return resolve(ok2(`Path ${path7} was not a directory`));
     } catch (error) {
       return reject(err2(error));
     }
@@ -1074,12 +781,12 @@ async function deleteEmptyFolders(dir) {
       return ok2(`Path ${dir} does not exist`);
     const files3 = fs.readdirSync(dir);
     for (const file of files3) {
-      const p3 = join(dir, file);
-      if (isFolder2(p3)) {
-        if (fs.readdirSync(p3).length === 0)
-          fs.rmSync(p3, { recursive: true, force: true });
+      const p4 = join(dir, file);
+      if (isFolder2(p4)) {
+        if (fs.readdirSync(p4).length === 0)
+          fs.rmSync(p4, { recursive: true, force: true });
         else
-          await deleteEmptyFolders(p3);
+          await deleteEmptyFolders(p4);
       }
     }
     return ok2(`Deleted empty folders located in ${dir}`);
@@ -1087,23 +794,23 @@ async function deleteEmptyFolders(dir) {
     return err2(error);
   }
 }
-var deleteFile = function(path62) {
+function deleteFile(path7) {
   return new Promise((resolve, reject) => {
     try {
-      if (isFile(path62)) {
-        fs.rmSync(path62, { recursive: true, force: true });
-        return resolve(ok2(`Deleted ${path62}`));
+      if (isFile(path7)) {
+        fs.rmSync(path7, { recursive: true, force: true });
+        return resolve(ok2(`Deleted ${path7}`));
       }
-      return resolve(ok2(`Path ${path62} was not a file`));
+      return resolve(ok2(`Path ${path7} was not a file`));
     } catch (error) {
       return reject(err2(error));
     }
   });
-};
-async function deleteGlob(path62) {
-  if (!path62.includes("*"))
-    return err2(handleError(`Path ${path62} does not contain a glob`));
-  const directories = await default2([path62], { onlyDirectories: true });
+}
+async function deleteGlob(path7) {
+  if (!path7.includes("*"))
+    return err2(handleError(`Path ${path7} does not contain a glob`));
+  const directories = await default2([path7], { onlyDirectories: true });
   for (const directory of directories) {
     const result = await deleteFolder(directory);
     if (result.isErr()) {
@@ -1114,15 +821,16 @@ async function deleteGlob(path62) {
   }
   return ok2(`Deleted ${directories.length} directories`);
 }
-async function del(path62) {
-  if (isFile(path62))
-    return await deleteFile(path62);
-  if (isFolder2(path62))
-    return await deleteFolder(path62);
-  if (path62.includes("*"))
-    return await deleteGlob(path62);
-  return err2(handleError(`Path ${path62} cannot be deleted due to an unhandled condition. Please report this issue.`));
+async function del(path7) {
+  if (isFile(path7))
+    return await deleteFile(path7);
+  if (isFolder2(path7))
+    return await deleteFolder(path7);
+  if (path7.includes("*"))
+    return await deleteGlob(path7);
+  return err2(handleError(`Path ${path7} cannot be deleted due to an unhandled condition. Please report this issue.`));
 }
+// /home/runner/work/stacks/stacks/storage/framework/core/storage/src/zip.ts
 import {runCommand} from "@stacksjs/cli";
 async function zip(from, to, options) {
   const toPath = to || "archive.zip";
@@ -1136,126 +844,33 @@ async function unzip(paths) {
     return runCommand(`unzip ${paths.join(" ")}`);
   return runCommand(`unzip ${paths}`);
 }
-var archive = function(paths) {
+function archive(paths) {
   return zip(paths);
-};
-var unarchive = function(paths) {
+}
+function unarchive(paths) {
   return unzip(paths);
-};
-var compress = function(paths) {
+}
+function compress(paths) {
   return zip(paths);
-};
-var decompress = function(paths) {
+}
+function decompress(paths) {
   return unzip(paths);
-};
-var gzipSync = function(data, options) {
+}
+function gzipSync(data, options) {
   return Bun.gzipSync(data, options);
-};
-var gunzipSync = function(data) {
+}
+function gunzipSync(data) {
   return Bun.gunzipSync(data);
-};
-var deflateSync = function(data, options) {
+}
+function deflateSync(data, options) {
   return Bun.deflateSync(data, options);
-};
-var inflateSync = function(data) {
-  return Bun.inflateSync(data);
-};
-import {err as err22, ok as ok22} from "@stacksjs/error-handling";
-import {log as log22} from "@stacksjs/logging";
-import {path as path72} from "@stacksjs/path";
-async function move2(src, dest, options) {
-  try {
-    if (Array.isArray(src)) {
-      const operations = src.map(async (file) => {
-        const from2 = file;
-        const to2 = path72.resolve(dest, path72.basename(file));
-        const result2 = await rename(from2, to2, options);
-        if (result2.isErr()) {
-          log22.error(result2.error);
-          return err22(handleError(result2.error.message, result2.error));
-        }
-      });
-      await Promise.all(operations);
-      return ok22({ message: "Files moved successfully" });
-    }
-    const from = src;
-    const to = dest;
-    const result = await rename(from, to, options);
-    if (result.isErr()) {
-      log22.error(result.error);
-      return err22(handleError(result.error));
-    }
-    return ok22({ message: "File moved successfully" });
-  } catch (error) {
-    return err22(handleError(error));
-  }
 }
-async function rename(from, to, options) {
-  return new Promise((resolve, reject) => {
-    try {
-      const dir = path72.dirname(to);
-      if (!fs.existsSync(dir))
-        fs.mkdirSync(dir, { recursive: true });
-      if (!fs.existsSync(from))
-        return reject(err22(new Error(`File or directory does not exist: ${from}`)));
-      if (fs.existsSync(to)) {
-        if (!options?.overwrite)
-          return reject(err22(new Error(`File or directory already exists: ${to}`)));
-        fs.unlinkSync(to);
-      }
-      fs.renameSync(from, to);
-      return resolve(ok22({ message: "File moved successfully" }));
-    } catch (error) {
-      if (error.code === "ENOENT")
-        log22.error("File or directory does not exist\n\n", error);
-      else
-        log22.error(error);
-      return reject(err22(new Error(error)));
-    }
-  });
+function inflateSync(data) {
+  return Bun.inflateSync(data);
 }
-var setVisibility = function() {
-  return "wip";
-};
-var __defProp2 = Object.defineProperty;
-var __export2 = (target, all) => {
-  for (var name in all)
-    __defProp2(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: (newValue) => all[name] = () => newValue
-    });
-};
-var files = {
-  readJsonFile,
-  readPackageJson,
-  readTextFile,
-  writeJsonFile,
-  writeTextFile,
-  isFile,
-  hasFiles,
-  hasComponents,
-  hasFunctions,
-  deleteFiles,
-  getFiles,
-  put,
-  get
-};
-var folders = {
-  isFolder: isFolder2,
-  doesFolderExist,
-  createFolder: createFolder2,
-  getFolders
-};
-var __dirname2 = "/Users/chrisbreuer/Code/stacks/storage/framework/core/storage/src";
-var _dirname = typeof __dirname2 !== "undefined" ? __dirname2 : dirname2(fileURLToPath(import.meta.url));
-var helpers = {
-  _dirname,
-  updateConfigFile
-};
+// /home/runner/work/stacks/stacks/storage/framework/core/storage/src/storage.ts
 var exports_storage = {};
-__export2(exports_storage, {
+__export(exports_storage, {
   zip: () => {
     {
       return zip;
@@ -1368,7 +983,7 @@ __export2(exports_storage, {
   },
   helpers: () => {
     {
-      return helpers;
+      return helpers3;
     }
   },
   hasFunctions: () => {
@@ -1428,7 +1043,7 @@ __export2(exports_storage, {
   },
   existsSync: () => {
     {
-      return existsSync2;
+      return existsSync;
     }
   },
   exists: () => {
@@ -1533,8 +1148,67 @@ __export2(exports_storage, {
   }
 });
 
+// /home/runner/work/stacks/stacks/storage/framework/core/storage/src/move.ts
+import {err as err3, ok as ok3} from "@stacksjs/error-handling";
+import {log as log3} from "@stacksjs/logging";
+import {path as path8} from "@stacksjs/path";
+async function move2(src, dest, options) {
+  try {
+    if (Array.isArray(src)) {
+      const operations = src.map(async (file) => {
+        const from2 = file;
+        const to2 = path8.resolve(dest, path8.basename(file));
+        const result2 = await rename(from2, to2, options);
+        if (result2.isErr()) {
+          log3.error(result2.error);
+          return err3(handleError(result2.error.message, result2.error));
+        }
+      });
+      await Promise.all(operations);
+      return ok3({ message: "Files moved successfully" });
+    }
+    const from = src;
+    const to = dest;
+    const result = await rename(from, to, options);
+    if (result.isErr()) {
+      log3.error(result.error);
+      return err3(handleError(result.error));
+    }
+    return ok3({ message: "File moved successfully" });
+  } catch (error) {
+    return err3(handleError(error));
+  }
+}
+async function rename(from, to, options) {
+  return new Promise((resolve, reject) => {
+    try {
+      const dir = path8.dirname(to);
+      if (!fs.existsSync(dir))
+        fs.mkdirSync(dir, { recursive: true });
+      if (!fs.existsSync(from))
+        return reject(err3(new Error(`File or directory does not exist: ${from}`)));
+      if (fs.existsSync(to)) {
+        if (!options?.overwrite)
+          return reject(err3(new Error(`File or directory already exists: ${to}`)));
+        fs.unlinkSync(to);
+      }
+      fs.renameSync(from, to);
+      return resolve(ok3({ message: "File moved successfully" }));
+    } catch (error) {
+      if (error.code === "ENOENT")
+        log3.error("File or directory does not exist\n\n", error);
+      else
+        log3.error(error);
+      return reject(err3(new Error(error)));
+    }
+  });
+}
+// /home/runner/work/stacks/stacks/storage/framework/core/storage/src/visibility.ts
+function setVisibility() {
+  return "wip";
+}
 // src/cloud/cdn.ts
-import {path as p3} from "@stacksjs/path";
+import {path as p4} from "@stacksjs/path";
 import {env as env2} from "@stacksjs/env";
 
 class CdnStack {
@@ -1677,9 +1351,9 @@ class CdnStack {
   }
   apiBehaviorOptions(scope, props) {
     const hostname = Fn.select(2, Fn.split("/", props.webServerUrl.url));
-    const origin = (path9 = "/api") => {
+    const origin = (path10 = "/api") => {
       return new origins.HttpOrigin(hostname, {
-        originPath: path9,
+        originPath: path10,
         protocolPolicy: cloudfront.OriginProtocolPolicy.HTTPS_ONLY
       });
     };
@@ -1791,7 +1465,7 @@ class CdnStack {
     return config6.cloud.cli;
   }
   shouldDeployDocs() {
-    return hasFiles(p3.projectPath("docs"));
+    return hasFiles(p4.projectPath("docs"));
   }
   additionalBehaviors(scope, props) {
     let behaviorOptions = {};
@@ -1895,7 +1569,7 @@ class DnsStack {
 // src/cloud/docs.ts
 import {AssetHashType, CfnOutput as Output4, RemovalPolicy as RemovalPolicy2, aws_lambda as lambda3} from "aws-cdk-lib";
 import {config as config8} from "@stacksjs/config";
-import {path as p4} from "@stacksjs/path";
+import {path as p5} from "@stacksjs/path";
 import {originRequestFunctionHash} from "@stacksjs/utils";
 
 class DocsStack {
@@ -1907,14 +1581,14 @@ class DocsStack {
       description: "The Stacks Origin Request function that prettifies URLs",
       runtime: lambda3.Runtime.NODEJS_18_X,
       handler: "dist/origin-request.handler",
-      code: lambda3.Code.fromAsset(p4.corePath("cloud/dist.zip"), {
+      code: lambda3.Code.fromAsset(p5.corePath("cloud/dist.zip"), {
         assetHash: originRequestFunctionHash,
         assetHashType: AssetHashType.CUSTOM
       })
     });
     const cfnOriginRequestFunction = this.originRequestFunction.node.defaultChild;
     cfnOriginRequestFunction.applyRemovalPolicy(RemovalPolicy2.RETAIN);
-    if (!config8.app.docMode && exports_storage.hasFiles(p4.projectPath("docs"))) {
+    if (!config8.app.docMode && exports_storage.hasFiles(p5.projectPath("docs"))) {
       new Output4(scope, "DocsUrl", {
         value: `https://${props.domain}/${docsPrefix}`,
         description: "The URL of the deployed documentation"
@@ -2664,7 +2338,7 @@ class PermissionsStack {
 
 // src/cloud/compute.ts
 import {Duration as Duration6, CfnOutput as Output6, aws_lambda as lambda5, aws_logs as logs, aws_secretsmanager as secretsmanager} from "aws-cdk-lib";
-import {path as p5} from "@stacksjs/path";
+import {path as p6} from "@stacksjs/path";
 import {env as env6} from "@stacksjs/env";
 
 class ComputeStack {
@@ -2678,7 +2352,7 @@ class ComputeStack {
     this.apiServer = new lambda5.Function(scope, "WebServer", {
       functionName: `${props.slug}-${props.appEnv}-web-server`,
       description: "The web server for the Stacks application",
-      code: lambda5.Code.fromAssetImage(p5.frameworkPath("server")),
+      code: lambda5.Code.fromAssetImage(p6.frameworkPath("server")),
       handler: lambda5.Handler.FROM_IMAGE,
       runtime: lambda5.Runtime.FROM_IMAGE,
       vpc,
@@ -2779,135 +2453,13 @@ class Cloud extends Stack2 {
     });
   }
 }
-// /Users/chrisbreuer/Code/stacks/storage/framework/core/router/dist/index.js
-import process2 from "process";
+// /home/runner/work/stacks/stacks/storage/framework/core/router/src/middleware.ts
+import {appPath} from "@stacksjs/path";
 async function importMiddlewares(directory) {
   return [directory];
 }
-import {extname as extname2} from "path";
-import {URL} from "url";
-import {localUrl} from "@stacksjs/config";
-async function serverResponse(req) {
-  console.log("serverResponse", req);
-  const routesList = await route.getRoutes();
-  const url = new URL(req.url);
-  const foundRoute = routesList.find((route2) => {
-    const pattern = new RegExp(`^${route2.uri.replace(/:\w+/g, "\\w+")}$`);
-    return pattern.test(url.pathname);
-  });
-  if (!foundRoute)
-    return new Response("Not found", { status: 404 });
-  addRouteParamsAndQuery(url, foundRoute);
-  executeMiddleware(foundRoute);
-  return execute(foundRoute, req, { statusCode: foundRoute?.statusCode });
-}
-var normalizeWindowsPath = function(input = "") {
-  if (!input) {
-    return input;
-  }
-  return input.replace(/\\/g, "/").replace(_DRIVE_LETTER_START_RE, (r) => r.toUpperCase());
-};
-var cwd = function() {
-  if (typeof process !== "undefined" && typeof process.cwd === "function") {
-    return process.cwd().replace(/\\/g, "/");
-  }
-  return "/";
-};
-var normalizeString = function(path11, allowAboveRoot) {
-  let res = "";
-  let lastSegmentLength = 0;
-  let lastSlash = -1;
-  let dots = 0;
-  let char = null;
-  for (let index = 0;index <= path11.length; ++index) {
-    if (index < path11.length) {
-      char = path11[index];
-    } else if (char === "/") {
-      break;
-    } else {
-      char = "/";
-    }
-    if (char === "/") {
-      if (lastSlash === index - 1 || dots === 1)
-        ;
-      else if (dots === 2) {
-        if (res.length < 2 || lastSegmentLength !== 2 || res[res.length - 1] !== "." || res[res.length - 2] !== ".") {
-          if (res.length > 2) {
-            const lastSlashIndex = res.lastIndexOf("/");
-            if (lastSlashIndex === -1) {
-              res = "";
-              lastSegmentLength = 0;
-            } else {
-              res = res.slice(0, lastSlashIndex);
-              lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
-            }
-            lastSlash = index;
-            dots = 0;
-            continue;
-          } else if (res.length > 0) {
-            res = "";
-            lastSegmentLength = 0;
-            lastSlash = index;
-            dots = 0;
-            continue;
-          }
-        }
-        if (allowAboveRoot) {
-          res += res.length > 0 ? "/.." : "..";
-          lastSegmentLength = 2;
-        }
-      } else {
-        if (res.length > 0) {
-          res += `/${path11.slice(lastSlash + 1, index)}`;
-        } else {
-          res = path11.slice(lastSlash + 1, index);
-        }
-        lastSegmentLength = index - lastSlash - 1;
-      }
-      lastSlash = index;
-      dots = 0;
-    } else if (char === "." && dots !== -1) {
-      ++dots;
-    } else {
-      dots = -1;
-    }
-  }
-  return res;
-};
-var _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
-var _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/;
-var resolve = function(...arguments_) {
-  arguments_ = arguments_.map((argument) => normalizeWindowsPath(argument));
-  let resolvedPath = "";
-  let resolvedAbsolute = false;
-  for (let index = arguments_.length - 1;index >= -1 && !resolvedAbsolute; index--) {
-    const path11 = index >= 0 ? arguments_[index] : cwd();
-    if (!path11 || path11.length === 0) {
-      continue;
-    }
-    resolvedPath = `${path11}/${resolvedPath}`;
-    resolvedAbsolute = isAbsolute(path11);
-  }
-  resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute);
-  if (resolvedAbsolute && !isAbsolute(resolvedPath)) {
-    return `/${resolvedPath}`;
-  }
-  return resolvedPath.length > 0 ? resolvedPath : ".";
-};
-var isAbsolute = function(p6) {
-  return _IS_ABSOLUTE_RE.test(p6);
-};
-var appPath = function(path22) {
-  return projectPath(`app/${path22 || ""}`);
-};
-var projectPath = function(filePath = "") {
-  let path22 = process2.cwd();
-  while (path22.includes("storage"))
-    path22 = resolve(path22, "..");
-  return resolve(path22, filePath);
-};
 var middlewares = await importMiddlewares(appPath("middleware"));
-
+// /home/runner/work/stacks/stacks/storage/framework/core/router/src/request.ts
 class Request {
   query = {};
   params = null;
@@ -2927,7 +2479,7 @@ class Request {
     return Object.keys(this.query).length === 0;
   }
   extractParamsFromRoute(routePattern, pathname) {
-    const pattern = new RegExp(`^${routePattern.replace(/:(\w+)/g, (match2, paramName) => `(?<${paramName}>\\w+)`)}$`);
+    const pattern = new RegExp(`^${routePattern.replace(/:(\w+)/g, (match2, paramName) => `(?<${paramName}>\\w+)`)}\$`);
     const match = pattern.exec(pathname);
     if (match?.groups)
       this.params = match?.groups;
@@ -2937,6 +2489,24 @@ class Request {
   }
 }
 var request = new Request;
+// /home/runner/work/stacks/stacks/storage/framework/core/router/src/server.ts
+import {extname} from "path";
+import {URL} from "url";
+import {localUrl} from "@stacksjs/config";
+async function serverResponse(req) {
+  console.log("serverResponse", req);
+  const routesList = await route.getRoutes();
+  const url = new URL(req.url);
+  const foundRoute = routesList.find((route2) => {
+    const pattern = new RegExp(`^${route2.uri.replace(/:\w+/g, "\\w+")}\$`);
+    return pattern.test(url.pathname);
+  });
+  if (!foundRoute)
+    return new Response("Not found", { status: 404 });
+  addRouteParamsAndQuery(url, foundRoute);
+  executeMiddleware(foundRoute);
+  return execute(foundRoute, req, { statusCode: foundRoute?.statusCode });
+}
 var addRouteParamsAndQuery = function(url, route2) {
   if (!isObjectNotEmpty(url.searchParams))
     request.addQuery(url);
@@ -2972,7 +2542,7 @@ var execute = function(route2, request3, { statusCode }) {
   }
   if (route2?.method !== request3.method)
     return new Response("Method not allowed", { status: 405 });
-  if (isString(route2.callback) && extname2(route2.callback) === ".html") {
+  if (isString(route2.callback) && extname(route2.callback) === ".html") {
     try {
       const fileContent = Bun.file(route2.callback);
       return new Response(fileContent, { headers: { "Content-Type": "text/html" } });
@@ -3008,6 +2578,8 @@ var isFunction = function(val) {
 var isObject = function(val) {
   return val !== null && typeof val === "object" && !Array.isArray(val);
 };
+// /home/runner/work/stacks/stacks/storage/framework/core/router/src/router.ts
+import {projectPath} from "@stacksjs/path";
 
 class Router {
   routes = [];
@@ -3015,7 +2587,7 @@ class Router {
     const name = uri.replace(/\//g, ".").replace(/:/g, "");
     const pattern = new RegExp(`^${uri.replace(/:[a-zA-Z]+/g, (_match) => {
       return "([a-zA-Z0-9-]+)";
-    })}$`);
+    })}\$`);
     let routeCallback;
     if (typeof callback === "string" || typeof callback === "object") {
       routeCallback = () => callback;
@@ -3033,32 +2605,32 @@ class Router {
       paramNames: []
     });
   }
-  get(path42, callback) {
-    this.addRoute("GET", path42, callback, 200);
+  get(path14, callback) {
+    this.addRoute("GET", path14, callback, 200);
     return this;
   }
-  post(path42, callback) {
-    this.addRoute("POST", path42, callback, 201);
+  post(path14, callback) {
+    this.addRoute("POST", path14, callback, 201);
     return this;
   }
-  view(path42, callback) {
-    this.addRoute("GET", path42, callback, 200);
+  view(path14, callback) {
+    this.addRoute("GET", path14, callback, 200);
     return this;
   }
-  redirect(path42, callback, _status) {
-    this.addRoute("GET", path42, callback, 302);
+  redirect(path14, callback, _status) {
+    this.addRoute("GET", path14, callback, 302);
     return this;
   }
-  delete(path42, callback) {
-    this.addRoute("DELETE", path42, callback, 204);
+  delete(path14, callback) {
+    this.addRoute("DELETE", path14, callback, 204);
     return this;
   }
-  patch(path42, callback) {
-    this.addRoute("PATCH", path42, callback, 202);
+  patch(path14, callback) {
+    this.addRoute("PATCH", path14, callback, 202);
     return this;
   }
-  put(path42, callback) {
-    this.addRoute("PUT", path42, callback, 202);
+  put(path14, callback) {
+    this.addRoute("PUT", path14, callback, 202);
     return this;
   }
   group(options, callback) {
@@ -3103,21 +2675,20 @@ class Router {
   }
 }
 var route = new Router;
-
 // src/runtime/server.ts
 var server_default = {
-  async fetch(request2, server) {
+  async fetch(request4, server2) {
     console.log("Request", {
-      url: request2.url,
-      method: request2.method,
-      headers: request2.headers.toJSON(),
-      body: request2.body ? await request2.text() : null
+      url: request4.url,
+      method: request4.method,
+      headers: request4.headers.toJSON(),
+      body: request4.body ? await request4.text() : null
     });
-    if (server.upgrade(request2)) {
+    if (server2.upgrade(request4)) {
       console.log("WebSocket upgraded");
       return;
     }
-    return serverResponse(request2);
+    return serverResponse(request4);
   },
   websocket: {}
 };