@valbuild/server 0.16.4 → 0.17.0

package/dist/declarations/src/LocalValServer.d.ts

@@ -3,17 +3,19 @@ import { Service } from "./Service.js";
 import { ValServer } from "./ValServer.js";
 export type LocalValServerOptions = {
     service: Service;
+    git: {
+        commit?: string;
+        branch?: string;
+    };
 };
 export declare class LocalValServer implements ValServer {
     readonly options: LocalValServerOptions;
     constructor(options: LocalValServerOptions);
-    getAllModules(req: express.Request, res: express.Response): Promise<void>;
     session(_req: express.Request, res: express.Response): Promise<void>;
+    getTree(req: express.Request, res: express.Response): Promise<void>;
     enable(req: express.Request, res: express.Response): Promise<void>;
-    getIds(req: express.Request<{
-        0: string;
-    }>, res: express.Response): Promise<void>;
-    patchIds(req: express.Request<{
+    disable(req: express.Request, res: express.Response): Promise<void>;
+    postPatches(req: express.Request<{
         0: string;
     }>, res: express.Response): Promise<void>;
     private badRequest;

package/dist/declarations/src/ValServer.d.ts

@@ -4,15 +4,11 @@ export interface ValServer {
     callback(req: express.Request, res: express.Response): Promise<void>;
     logout(req: express.Request, res: express.Response): Promise<void>;
     session(req: express.Request, res: express.Response): Promise<void>;
-    getIds(req: express.Request<{
-        0: string;
-    }>, res: express.Response): Promise<void>;
-    getAllModules(req: express.Request<{
-        0: string;
-    }>, res: express.Response): Promise<void>;
-    patchIds(req: express.Request<{
+    postPatches(req: express.Request<{
         0: string;
     }>, res: express.Response): Promise<void>;
     commit(req: express.Request, res: express.Response): Promise<void>;
     enable(req: express.Request, res: express.Response): Promise<void>;
+    disable(req: express.Request, res: express.Response): Promise<void>;
+    getTree(req: express.Request, res: express.Response): Promise<void>;
 }

package/dist/declarations/src/hosting.d.ts

@@ -66,6 +66,16 @@ type ValServerOverrides = Partial<{
      * @example "https://app.val.build"
      */
     valBuildUrl: string;
+    /**
+     * The base url of Val content.
+     *
+     * Typically this should not be set.
+     *
+     * Can also be overridden using the VAL_CONTENT_URL env var.
+     *
+     * @example "https://content.val.build"
+     */
+    valContentUrl: string;
     /**
      * The full name of this Val project.
      *
@@ -74,6 +84,30 @@ type ValServerOverrides = Partial<{
      * @example "myorg/my-project"
      */
     valName: string;
+    /**
+     * After Val is enabled, redirect to this url.
+     *
+     * May be used to setup a custom flow after enabling Val.
+     *
+     *This can be set using the VAL_ENABLE_REDIRECT_URL env var.
+     *
+     * @example "/api/draft/enable"
+     */
+    valEnableRedirectUrl?: string;
+    /**
+     * After Val is disabled, redirect to this url.
+     *
+     * May be used to setup a custom flow after disabling Val.
+     *
+     * This can be set using the VAL_DISABLE_REDIRECT_URL env var.
+     *
+     * @example "/api/draft/enable"
+     */
+    valDisableRedirectUrl?: string;
+}>;
+export declare function safeReadGit(cwd: string): Promise<{
+    commit?: string;
+    branch?: string;
 }>;
 export declare function createRequestListener(route: string, opts: Opts): RequestListener;
 export {};

package/dist/declarations/src/index.d.ts

@@ -1,7 +1,7 @@
 export type { ServiceOptions } from "./Service.js";
 export { createService, Service } from "./Service.js";
 export { createRequestHandler } from "./createRequestHandler.js";
-export { createRequestListener } from "./hosting.js";
+export { createRequestListener, safeReadGit } from "./hosting.js";
 export { ValModuleLoader } from "./ValModuleLoader.js";
 export { getCompilerOptions } from "./getCompilerOptions.js";
 export { ValSourceFileHandler } from "./ValSourceFileHandler.js";

package/dist/valbuild-server.cjs.dev.js

@@ -17,8 +17,26 @@ var sizeOf = require('image-size');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { 'default': e }; }
 
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n["default"] = e;
+  return Object.freeze(n);
+}
+
 var ts__default = /*#__PURE__*/_interopDefault(ts);
-var path__default = /*#__PURE__*/_interopDefault(path);
+var path__namespace = /*#__PURE__*/_interopNamespace(path);
 var fs__default = /*#__PURE__*/_interopDefault(fs);
 var express__default = /*#__PURE__*/_interopDefault(express);
 var z__default = /*#__PURE__*/_interopDefault(z);
@@ -572,16 +590,16 @@ import { Internal } from "@valbuild/core";
 globalThis.valModule = { 
   id: valModule?.default && Internal.getValPath(valModule?.default),
   schema: valModule?.default && Internal.getSchema(valModule?.default)?.serialize(),
-  source: valModule?.default && Internal.getRawSource(valModule?.default),
+  source: valModule?.default && Internal.getSource(valModule?.default),
   validation: valModule?.default && Internal.getSchema(valModule?.default)?.validate(
     valModule?.default && Internal.getValPath(valModule?.default) || "/",
-    valModule?.default && Internal.getRawSource(valModule?.default)
+    valModule?.default && Internal.getSource(valModule?.default)
   )
 };
 `;
     const result = context.evalCode(code,
     // Synthetic module name
-    path__default["default"].join(path__default["default"].dirname(valConfigPath), "<val>"));
+    path__namespace["default"].join(path__namespace["default"].dirname(valConfigPath), "<val>"));
     const fatalErrors = [];
     if (result.error) {
       const error = result.error.consume(context.dump);
@@ -693,8 +711,8 @@ const patchSourceFile = (sourceFile, patch$1) => {
 };
 
 const getCompilerOptions = (rootDir, parseConfigHost) => {
-  const tsConfigPath = path__default["default"].resolve(rootDir, "tsconfig.json");
-  const jsConfigPath = path__default["default"].resolve(rootDir, "jsconfig.json");
+  const tsConfigPath = path__namespace["default"].resolve(rootDir, "tsconfig.json");
+  const jsConfigPath = path__namespace["default"].resolve(rootDir, "jsconfig.json");
   let configFilePath;
   if (parseConfigHost.fileExists(jsConfigPath)) {
     configFilePath = jsConfigPath;
@@ -744,7 +762,7 @@ class ValSourceFileHandler {
     this.host.writeFile(filePath, content, encoding);
   }
   resolveSourceModulePath(containingFilePath, requestedModuleName) {
-    const resolutionRes = ts__default["default"].resolveModuleName(requestedModuleName, path__default["default"].isAbsolute(containingFilePath) ? containingFilePath : path__default["default"].resolve(this.projectRoot, containingFilePath), this.compilerOptions, this.host, undefined, undefined, ts__default["default"].ModuleKind.ESNext);
+    const resolutionRes = ts__default["default"].resolveModuleName(requestedModuleName, path__namespace["default"].isAbsolute(containingFilePath) ? containingFilePath : path__namespace["default"].resolve(this.projectRoot, containingFilePath), this.compilerOptions, this.host, undefined, undefined, ts__default["default"].ModuleKind.ESNext);
     const resolvedModule = resolutionRes.resolvedModule;
     if (!resolvedModule) {
       throw Error(`Could not resolve module "${requestedModuleName}", base: "${containingFilePath}": No resolved modules returned: ${JSON.stringify(resolutionRes)}`);
@@ -864,6 +882,16 @@ async function newValQuickJSRuntime(quickJSModule, moduleLoader, {
           value: "export const useVal = () => { throw Error(`Cannot use 'useVal' in this type of file`) }; export const fetchVal = () => { throw Error(`Cannot use 'fetchVal' in this type of file`) }; export const autoTagJSX = () => { /* ignore */ };"
         };
       }
+      if (modulePath.startsWith("next")) {
+        return {
+          value: "export default new Proxy({}, { get() { return () => { throw new Error(`Cannot import 'next' in this file`) } } } )"
+        };
+      }
+      if (modulePath.startsWith("react")) {
+        return {
+          value: "export default new Proxy({}, { get() { return () => { throw new Error(`Cannot import 'react' in this file`) } } } )"
+        };
+      }
       return {
         value: moduleLoader.getModule(modulePath)
       };
@@ -884,6 +912,16 @@ async function newValQuickJSRuntime(quickJSModule, moduleLoader, {
           value: requestedName
         };
       }
+      if (requestedName.startsWith("next")) {
+        return {
+          value: requestedName
+        };
+      }
+      if (requestedName.startsWith("react")) {
+        return {
+          value: requestedName
+        };
+      }
       const modulePath = moduleLoader.resolveModulePath(baseModuleName, requestedName);
       return {
         value: modulePath
@@ -920,7 +958,7 @@ class Service {
     const valModule = await readValFile(moduleId, this.valConfigPath, this.runtime);
     if (valModule.source && valModule.schema) {
       const resolved = core.Internal.resolvePath(modulePath, valModule.source, valModule.schema);
-      const sourcePath = [moduleId, resolved.path].join(".");
+      const sourcePath = resolved.path ? [moduleId, resolved.path].join(".") : moduleId;
       return {
         path: sourcePath,
         schema: resolved.schema instanceof core.Schema ? resolved.schema.serialize() : resolved.schema,
@@ -951,14 +989,14 @@ function createRequestHandler(valServer) {
   router.get("/authorize", valServer.authorize.bind(valServer));
   router.get("/callback", valServer.callback.bind(valServer));
   router.get("/logout", valServer.logout.bind(valServer));
-  router.get("/ids/*", valServer.getIds.bind(valServer));
-  router.get("/ids", valServer.getAllModules.bind(valServer));
-  router.patch("/ids/*", express__default["default"].json({
-    type: "application/json-patch+json",
+  router.post("/patches/*", express__default["default"].json({
+    type: "application/json",
     limit: "10mb"
-  }), valServer.patchIds.bind(valServer));
+  }), valServer.postPatches.bind(valServer));
   router.post("/commit", valServer.commit.bind(valServer));
   router.get("/enable", valServer.enable.bind(valServer));
+  router.get("/disable", valServer.disable.bind(valServer));
+  router.get("/tree/*", valServer.getTree.bind(valServer));
   return router;
 }
 
@@ -1062,19 +1100,13 @@ function encodeJwt(payload, sessionKey) {
   return `${jwtHeaderBase64}.${payloadBase64}.${crypto__default["default"].createHmac("sha256", sessionKey).update(`${jwtHeaderBase64}.${payloadBase64}`).digest("base64")}`;
 }
 
-const VAL_SESSION_COOKIE = "val_session";
-const VAL_STATE_COOKIE = "val_state";
+const VAL_SESSION_COOKIE = core.Internal.VAL_SESSION_COOKIE;
+const VAL_STATE_COOKIE = core.Internal.VAL_STATE_COOKIE;
 const VAL_ENABLED_COOKIE = core.Internal.VAL_ENABLE_COOKIE_NAME;
 class ProxyValServer {
   constructor(options) {
     this.options = options;
   }
-
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  getAllModules(_req, _res) {
-    // TODO:
-    throw new Error("Method not implemented.");
-  }
   async authorize(req, res) {
     const {
       redirect_to
@@ -1096,7 +1128,10 @@ class ProxyValServer {
     }).redirect(appAuthorizeUrl);
   }
   async enable(req, res) {
-    return enable(req, res);
+    return enable(req, res, this.options.valEnableRedirectUrl);
+  }
+  async disable(req, res) {
+    return disable(req, res, this.options.valEnableRedirectUrl);
   }
   async callback(req, res) {
     const {
@@ -1158,30 +1193,38 @@ class ProxyValServer {
       }
     });
   }
-  async getIds(req, res) {
-    return this.withAuth(req, res, async ({
-      token
-    }) => {
-      const id = getPathFromParams(req.params);
-      const url = new URL(`/api/val/modules/${encodeURIComponent(this.options.gitCommit)}${id}`, this.options.valBuildUrl);
-      const fetchRes = await fetch(url, {
-        headers: this.getAuthHeaders(token)
-      });
-      if (fetchRes.ok) {
-        res.status(fetchRes.status).json(await fetchRes.json());
-      } else {
-        res.sendStatus(fetchRes.status);
-      }
-    }).catch(e => {
-      res.status(500).send({
-        error: {
-          message: e === null || e === void 0 ? void 0 : e.message,
-          status: 500
-        }
+  async getTree(req, res) {
+    return this.withAuth(req, res, async data => {
+      const {
+        patch,
+        schema,
+        source
+      } = req.query;
+      const params = new URLSearchParams({
+        patch: (patch === "true").toString(),
+        schema: (schema === "true").toString(),
+        source: (source === "true").toString()
       });
+      const url = new URL(`/v1/tree/${this.options.valName}/heads/${this.options.gitBranch}/${req.params["0"]}/?${params}`, this.options.valContentUrl);
+      const json = await fetch(url, {
+        headers: this.getAuthHeaders(data.token, "application/json")
+      }).then(res => res.json());
+      res.send(json);
     });
   }
-  async patchIds(req, res) {
+  async postPatches(req, res) {
+    const {
+      commit
+    } = req.query;
+    if (typeof commit !== "string" || typeof commit === "undefined") {
+      res.status(401).json({
+        error: "Missing or invalid commit query param"
+      });
+      return;
+    }
+    const params = new URLSearchParams({
+      commit
+    });
     this.withAuth(req, res, async ({
       token
     }) => {
@@ -1197,12 +1240,11 @@ class ProxyValServer {
         res.status(401).json(patch$1.error);
         return;
       }
-      const id = getPathFromParams(req.params);
-      const url = new URL(`/api/val/modules/${encodeURIComponent(this.options.gitCommit)}${id}`, this.options.valBuildUrl);
+      const url = new URL(`/v1/tree/${this.options.valName}/heads/${this.options.gitBranch}/${req.params["0"]}/?${params}`, this.options.valContentUrl);
       // Proxy patch to val.build
       const fetchRes = await fetch(url, {
-        method: "PATCH",
-        headers: this.getAuthHeaders(token, "application/json-patch+json"),
+        method: "POST",
+        headers: this.getAuthHeaders(token, "application/json"),
         body: JSON.stringify(patch$1)
       });
       if (fetchRes.ok) {
@@ -1384,15 +1426,36 @@ function getStateFromCookie(stateCookie) {
     };
   }
 }
-async function enable(req, res) {
+async function enable(req, res, redirectUrl) {
   const {
     redirect_to
   } = req.query;
   if (typeof redirect_to === "string" || typeof redirect_to === "undefined") {
+    let redirectUrlToUse = redirect_to || "/";
+    if (redirectUrl) {
+      redirectUrlToUse = redirectUrl + "?redirect_to=" + encodeURIComponent(redirectUrlToUse);
+    }
     res.cookie(VAL_ENABLED_COOKIE, "true", {
       httpOnly: false,
       sameSite: "lax"
-    }).redirect(redirect_to || "/");
+    }).redirect(redirectUrlToUse);
+  } else {
+    res.sendStatus(400);
+  }
+}
+async function disable(req, res, redirectUrl) {
+  const {
+    redirect_to
+  } = req.query;
+  if (typeof redirect_to === "string" || typeof redirect_to === "undefined") {
+    let redirectUrlToUse = redirect_to || "/";
+    if (redirectUrl) {
+      redirectUrlToUse = redirectUrl + "?redirect_to=" + encodeURIComponent(redirectUrlToUse);
+    }
+    res.cookie(VAL_ENABLED_COOKIE, "false", {
+      httpOnly: false,
+      sameSite: "lax"
+    }).redirect(redirectUrlToUse);
   } else {
     res.sendStatus(400);
   }
@@ -1418,53 +1481,75 @@ class LocalValServer {
   constructor(options) {
     this.options = options;
   }
-  getAllModules(req, res) {
-    // TODO: this barely works,
-    const rootDir = process.cwd();
-    const moduleIds = [];
-    // iterate over all .val files in the root directory
-    const walk = async dir => {
-      const files = await fs.promises.readdir(dir);
-      for (const file of files) {
-        if ((await fs.promises.stat(path__default["default"].join(dir, file))).isDirectory()) {
-          if (file === "node_modules") continue;
-          await walk(path__default["default"].join(dir, file));
-        } else {
-          if (file.endsWith(".val.js") || file.endsWith(".val.ts")) {
-            moduleIds.push(path__default["default"].join(dir, file).replace(rootDir, "").replace(".val.js", "").replace(".val.ts", ""));
-          }
-        }
-      }
-    };
-    return walk(rootDir).then(async () => {
-      res.send(JSON.stringify(await Promise.all(moduleIds.map(async moduleId => {
-        return await this.options.service.get(moduleId, "");
-      }))));
-    });
-  }
   async session(_req, res) {
     res.json({
       mode: "local"
     });
   }
-  async enable(req, res) {
-    return enable(req, res);
-  }
-  async getIds(req, res) {
+  async getTree(req, res) {
     try {
-      console.log(req.params);
-      const path = getPathFromParams(req.params);
-      const [moduleId, modulePath] = core.Internal.splitModuleIdAndModulePath(path);
-      const valModule = await this.options.service.get(moduleId, modulePath);
-      res.json(valModule);
+      // TODO: use the params: patch, schema, source
+      const treePath = req.params["0"].replace("~", "");
+      const rootDir = process.cwd();
+      const moduleIds = [];
+      // iterate over all .val files in the root directory
+      const walk = async dir => {
+        const files = await fs.promises.readdir(dir);
+        for (const file of files) {
+          if ((await fs.promises.stat(path__namespace["default"].join(dir, file))).isDirectory()) {
+            if (file === "node_modules") continue;
+            await walk(path__namespace["default"].join(dir, file));
+          } else {
+            const isValFile = file.endsWith(".val.js") || file.endsWith(".val.ts");
+            if (!isValFile) {
+              continue;
+            }
+            if (treePath && !path__namespace["default"].join(dir, file).replace(rootDir, "").startsWith(treePath)) {
+              continue;
+            }
+            moduleIds.push(path__namespace["default"].join(dir, file).replace(rootDir, "").replace(".val.js", "").replace(".val.ts", ""));
+          }
+        }
+      };
+      const serializedModuleContent = await walk(rootDir).then(async () => {
+        return Promise.all(moduleIds.map(async moduleId => {
+          return await this.options.service.get(moduleId, "");
+        }));
+      });
+
+      //
+      const modules = Object.fromEntries(serializedModuleContent.map(serializedModuleContent => {
+        const module = {
+          schema: serializedModuleContent.schema,
+          source: serializedModuleContent.source
+        };
+        return [serializedModuleContent.path, module];
+      }));
+      const apiTreeResponse = {
+        modules,
+        git: this.options.git
+      };
+      return walk(rootDir).then(async () => {
+        res.send(JSON.stringify(apiTreeResponse));
+      });
     } catch (err) {
       console.error(err);
       res.sendStatus(500);
     }
   }
-  async patchIds(req, res) {
+  async enable(req, res) {
+    return enable(req, res);
+  }
+  async disable(req, res) {
+    return disable(req, res);
+  }
+  async postPatches(req, res) {
+    var _getPathFromParams;
+    const id = (_getPathFromParams = getPathFromParams(req.params)) === null || _getPathFromParams === void 0 ? void 0 : _getPathFromParams.replace("/~", "");
+
     // First validate that the body has the right structure
     const patchJSON = PatchJSON.safeParse(req.body);
+    console.log("patch id", id, patchJSON);
     if (!patchJSON.success) {
       res.status(401).json(patchJSON.error.issues);
       return;
@@ -1475,16 +1560,19 @@ class LocalValServer {
       res.status(401).json(patch$1.error);
       return;
     }
-    const id = getPathFromParams(req.params);
     try {
-      const valModule = await this.options.service.patch(id, patch$1.value);
-      res.json(valModule);
+      await this.options.service.patch(id, patch$1.value);
+      res.json({});
     } catch (err) {
       if (err instanceof patch.PatchError) {
-        res.status(401).send(err.message);
+        res.status(400).send({
+          message: err.message
+        });
       } else {
         console.error(err);
-        res.status(500).send(err instanceof Error ? err.message : "Unknown error");
+        res.status(500).send({
+          message: err instanceof Error ? err.message : "Unknown error"
+        });
       }
     }
   }
@@ -1526,6 +1614,7 @@ async function initHandlerOptions(route, opts) {
     if (!maybeApiKey || !maybeValSecret) {
       throw new Error("VAL_API_KEY and VAL_SECRET env vars must both be set in proxy mode");
     }
+    const valContentUrl = opts.valContentUrl || process.env.VAL_CONTENT_URL || "https://content.val.build";
     const maybeGitCommit = opts.gitCommit || process.env.VAL_GIT_COMMIT;
     if (!maybeGitCommit) {
       throw new Error("VAL_GIT_COMMIT env var must be set in proxy mode");
@@ -1544,18 +1633,82 @@ async function initHandlerOptions(route, opts) {
       apiKey: maybeApiKey,
       valSecret: maybeValSecret,
       valBuildUrl,
+      valContentUrl,
       gitCommit: maybeGitCommit,
       gitBranch: maybeGitBranch,
-      valName: maybeValName
+      valName: maybeValName,
+      valEnableRedirectUrl: opts.valEnableRedirectUrl || process.env.VAL_ENABLE_REDIRECT_URL,
+      valDisableRedirectUrl: opts.valDisableRedirectUrl || process.env.VAL_DISABLE_REDIRECT_URL
     };
   } else {
-    const service = await createService(process.cwd(), opts);
+    const cwd = process.cwd();
+    const service = await createService(cwd, opts);
+    const git = await safeReadGit(cwd);
     return {
       mode: "local",
-      service
+      service,
+      git: {
+        commit: process.env.VAL_GIT_COMMIT || git.commit,
+        branch: process.env.VAL_GIT_BRANCH || git.branch
+      }
     };
   }
 }
+async function safeReadGit(cwd) {
+  async function findGitHead(currentDir, depth) {
+    const gitHeadPath = path__namespace.join(currentDir, ".git", "HEAD");
+    if (depth > 1000) {
+      console.error(`Reached max depth while scanning for .git folder. Current working dir: ${cwd}.`);
+      return {
+        commit: undefined,
+        branch: undefined
+      };
+    }
+    try {
+      const headContents = await fs.promises.readFile(gitHeadPath, "utf-8");
+      const match = headContents.match(/^ref: refs\/heads\/(.+)/);
+      if (match) {
+        const branchName = match[1];
+        return {
+          branch: branchName,
+          commit: await readCommit(currentDir, branchName)
+        };
+      } else {
+        return {
+          commit: undefined,
+          branch: undefined
+        };
+      }
+    } catch (error) {
+      const parentDir = path__namespace.dirname(currentDir);
+
+      // We've reached the root directory
+      if (parentDir === currentDir) {
+        return {
+          commit: undefined,
+          branch: undefined
+        };
+      }
+      return findGitHead(parentDir, depth + 1);
+    }
+  }
+  try {
+    return findGitHead(cwd, 0);
+  } catch (err) {
+    console.error("Error while reading .git", err);
+    return {
+      commit: undefined,
+      branch: undefined
+    };
+  }
+}
+async function readCommit(gitDir, branchName) {
+  try {
+    return (await fs.promises.readFile(path__namespace.join(gitDir, ".git", "refs", "heads", branchName), "utf-8")).trim();
+  } catch (err) {
+    return undefined;
+  }
+}
 
 // TODO: rename to createValApiHandlers?
 function createRequestListener(route, opts) {
@@ -1593,10 +1746,10 @@ class ValFSHost {
     return this.currentDirectory;
   }
   getCanonicalFileName(fileName) {
-    if (path__default["default"].isAbsolute(fileName)) {
-      return path__default["default"].normalize(fileName);
+    if (path__namespace["default"].isAbsolute(fileName)) {
+      return path__namespace["default"].normalize(fileName);
     }
-    return path__default["default"].resolve(this.getCurrentDirectory(), fileName);
+    return path__namespace["default"].resolve(this.getCurrentDirectory(), fileName);
   }
   fileExists(fileName) {
     return this.valFS.fileExists(fileName);
@@ -1617,7 +1770,7 @@ async function createFixPatch(config, apply, sourcePath, validationError) {
       // TODO:
       throw Error("Cannot fix image without a file reference");
     }
-    const localFile = path__default["default"].join(config.projectRoot, maybeRef);
+    const localFile = path__namespace["default"].join(config.projectRoot, maybeRef);
     const buffer = fs__default["default"].readFileSync(localFile);
     const sha256 = await getSHA256Hash(buffer);
     const imageSize = sizeOf__default["default"](buffer);
@@ -1734,3 +1887,4 @@ exports.formatSyntaxErrorTree = formatSyntaxErrorTree;
 exports.getCompilerOptions = getCompilerOptions;
 exports.getExpire = getExpire;
 exports.patchSourceFile = patchSourceFile;
+exports.safeReadGit = safeReadGit;