@valbuild/server 0.105.1 → 0.106.0

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

@@ -120,7 +120,14 @@ export type ValidationEvent = {
     sourcePath: string;
     fixes: string[];
     keyError?: boolean;
-} | {
+}
+/**
+ * A file that default exports a Val module, but that val.modules does not
+ * register — so Val will never serve it. Files that do NOT default export a
+ * module are not reported at all, and one whose default export is not a
+ * module is a `fatal-error`; see `reportUnregistered` in the CLI.
+ */
+ | {
     type: "unregistered-module";
     file: string;
 } | {

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

@@ -33,7 +33,8 @@ export { extractJsonValuesEntry } from "./extractJsonValuesEntry.js";
 export type { ModulePathMap } from "./modulePathMap.js";
 export { ValOpsFS } from "./ValOpsFS.js";
 export { ValOpsHttp } from "./ValOpsHttp.js";
-export { loadValModules } from "./loadValModules.js";
+export { loadValModules, createValModuleFileInspector } from "./loadValModules.js";
+export type { ValModuleFileInspection } from "./loadValModules.js";
 export { formatPatchSourceError } from "./ValOps.js";
 export { compareWithCapturedReport, readCapturedReport, replaySnapshot, } from "./debug/replaySnapshot.js";
 export type { ReplayComparison, ReplayResult } from "./debug/replaySnapshot.js";

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

@@ -1,5 +1,5 @@
 import ts from "typescript";
-import type { ValModules } from "@valbuild/core";
+import { type ValModules } from "@valbuild/core";
 /**
  * The filesystem seam `loadValModules` reads through.
  *
@@ -31,3 +31,43 @@ export type ValModulesHost = ts.ParseConfigHost & ts.ModuleResolutionHost;
  * evaluate untrusted or third-party modules.
  */
 export declare function loadValModules(projectRoot: string, host?: ValModulesHost): ValModules;
+/**
+ * What a `*.val.ts` file that is NOT registered in `val.modules` turns out to
+ * be.
+ *
+ * A file matching `*.val.ts` is not necessarily a Val module: the same
+ * convention is used for shared schemas and other content-adjacent helpers, and
+ * those are not meant to be registered. Only a file that actually default
+ * exports a module is worth warning about; one that default exports something
+ * else is a mistake, because nothing will ever load it.
+ *
+ * See {@link createValModuleFileInspector}.
+ */
+export type ValModuleFileInspection = 
+/** No default export at all: not a Val module, and not trying to be one. */
+{
+    status: "no-default-export";
+}
+/** A real Val module — `export default c.define(...)`. */
+ | {
+    status: "val-module";
+}
+/** A default export that is not a Val module, or that would not evaluate. */
+ | {
+    status: "invalid";
+    message: string;
+};
+/**
+ * Inspects individual `*.val.{ts,js}` files, sharing one module cache and one
+ * parsed tsconfig across every call.
+ *
+ * The default export is checked SYNTACTICALLY first and only evaluated if it is
+ * there. That ordering is the point: a `.val.ts` with no default export is a
+ * helper file, and evaluating it to learn that would be both wasted work and a
+ * way to turn an unrelated top-level throw into a reported error.
+ *
+ * SECURITY: evaluation goes through the same `vm` loader as
+ * {@link loadValModules} — see the warning there. Only ever point this at the
+ * project's own first-party files.
+ */
+export declare function createValModuleFileInspector(projectRoot: string, host?: ValModulesHost): (absPath: string) => ValModuleFileInspection;

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

@@ -896,6 +896,150 @@ function resolveRelative(dirName, spec, host) {
   return null;
 }
 
+/**
+ * What a `*.val.ts` file that is NOT registered in `val.modules` turns out to
+ * be.
+ *
+ * A file matching `*.val.ts` is not necessarily a Val module: the same
+ * convention is used for shared schemas and other content-adjacent helpers, and
+ * those are not meant to be registered. Only a file that actually default
+ * exports a module is worth warning about; one that default exports something
+ * else is a mistake, because nothing will ever load it.
+ *
+ * See {@link createValModuleFileInspector}.
+ */
+
+/**
+ * Inspects individual `*.val.{ts,js}` files, sharing one module cache and one
+ * parsed tsconfig across every call.
+ *
+ * The default export is checked SYNTACTICALLY first and only evaluated if it is
+ * there. That ordering is the point: a `.val.ts` with no default export is a
+ * helper file, and evaluating it to learn that would be both wasted work and a
+ * way to turn an unrelated top-level throw into a reported error.
+ *
+ * SECURITY: evaluation goes through the same `vm` loader as
+ * {@link loadValModules} — see the warning there. Only ever point this at the
+ * project's own first-party files.
+ */
+function createValModuleFileInspector(projectRoot, host = ts__default["default"].sys) {
+  const compilerOptions = getCompilerOptions(projectRoot, host);
+  const cache = {};
+  return absPath => {
+    const code = host.readFile(absPath);
+    if (code === undefined) {
+      return {
+        status: "invalid",
+        message: `Could not read file: '${absPath}'`
+      };
+    }
+    const sourceFile = ts__default["default"].createSourceFile(absPath, code, ts__default["default"].ScriptTarget.ES2020, true);
+    if (!hasDefaultExport(sourceFile)) {
+      return {
+        status: "no-default-export"
+      };
+    }
+    let exports;
+    // `loadModule` inserts a module into the cache BEFORE evaluating it, so
+    // that a cycle resolves. One that throws therefore leaves a half-built
+    // entry behind - and unlike `loadValModules`, which builds a cache per
+    // call and lets the throw escape, this cache outlives the failure. A later
+    // inspection of the same file (or of the helper that actually threw) would
+    // hit that entry, see empty exports, and report "default export is
+    // undefined" instead of the real error - or, worse, quietly downgrade it to
+    // a warning. So roll the cache back to what it was before this attempt.
+    const before = new Set(Object.keys(cache));
+    try {
+      exports = loadModule(absPath, cache, compilerOptions, host).exports;
+    } catch (e) {
+      for (const key of Object.keys(cache)) {
+        if (!before.has(key)) {
+          delete cache[key];
+        }
+      }
+      return {
+        status: "invalid",
+        message: `Could not be loaded. Error: ${errorMessage(e)}`
+      };
+    }
+    if (core.Internal.isValModule(exports.default)) {
+      return {
+        status: "val-module"
+      };
+    }
+    // NOTE: do NOT suggest wrapping this in `c.define`. A shared schema turned
+    // into a module is an UNREGISTERED module, i.e. straight back to a warning.
+    // The fix is to move it out of the default export slot, which is the one
+    // thing about a `.val.ts` that Val reserves for itself.
+    return {
+      status: "invalid",
+      message: `Default export is ${describeDefaultExport(exports.default)}, not a Val module. Only 'c.define(...)' may be the default export of a '*.val.ts' file: use a named export for a shared schema or helper`
+    };
+  };
+}
+
+/**
+ * Whether the file exports a RUNTIME value as `default`, without evaluating it.
+ *
+ * Two things deliberately do not count, because neither exists once the file is
+ * transpiled — and treating either as a default export would send a pure helper
+ * off to be evaluated and reported:
+ *
+ *  - `export * from "./x"`, since a star re-export never carries the default;
+ *  - a type-only export, in either of its spellings
+ *    (`export type { T as default }` and `export { type T as default }`).
+ */
+function hasDefaultExport(sourceFile) {
+  return sourceFile.statements.some(statement => {
+    // `export default <expr>` — but not `export = x`, which shares this node.
+    if (ts__default["default"].isExportAssignment(statement)) {
+      return !statement.isExportEquals;
+    }
+    // `export { x as default }` / `export { default } from "./x"`
+    if (ts__default["default"].isExportDeclaration(statement) && !statement.isTypeOnly && statement.exportClause && ts__default["default"].isNamedExports(statement.exportClause)) {
+      return statement.exportClause.elements.some(element => !element.isTypeOnly && element.name.text === "default");
+    }
+    // `export default function f() {}` / `export default class C {}`, which are
+    // declarations carrying a `default` modifier rather than export assignments.
+    return ts__default["default"].canHaveModifiers(statement) && (ts__default["default"].getModifiers(statement) ?? []).some(modifier => modifier.kind === ts__default["default"].SyntaxKind.DefaultKeyword);
+  });
+}
+
+/** A short, human-readable "what you exported instead" for the error message. */
+function describeDefaultExport(value) {
+  if (value === null) {
+    return "null";
+  }
+  if (Array.isArray(value)) {
+    return "an array";
+  }
+  if (typeof value === "object") {
+    // Duck-typed rather than `instanceof Schema`, for the same cross-realm
+    // reason `isValModule` avoids a constructor check.
+    if ("executeSerialize" in value && typeof value["executeSerialize"] === "function") {
+      return "a schema";
+    }
+    return "an object";
+  }
+  if (typeof value === "undefined") {
+    return "undefined";
+  }
+  return `a ${typeof value}`;
+}
+function errorMessage(e) {
+  // NOT `e instanceof Error`: an error thrown from inside the `vm` context is
+  // built from that realm's Error constructor. Duck-type the message instead.
+  if (typeof e === "object" && e !== null && "message" in e) {
+    const {
+      message
+    } = e;
+    if (typeof message === "string") {
+      return message;
+    }
+  }
+  return String(e);
+}
+
 const jsonOps$1 = new patch.JSONOps();
 
 /**
@@ -12531,6 +12675,7 @@ exports.createJsonEntryPathMap = createJsonEntryPathMap;
 exports.createModulePathMap = createModulePathMap;
 exports.createService = createService;
 exports.createValApiRouter = createValApiRouter;
+exports.createValModuleFileInspector = createValModuleFileInspector;
 exports.createValServer = createValServer;
 exports.currentFixHandlers = currentFixHandlers;
 exports.decodeJwt = decodeJwt;

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

@@ -896,6 +896,150 @@ function resolveRelative(dirName, spec, host) {
   return null;
 }
 
+/**
+ * What a `*.val.ts` file that is NOT registered in `val.modules` turns out to
+ * be.
+ *
+ * A file matching `*.val.ts` is not necessarily a Val module: the same
+ * convention is used for shared schemas and other content-adjacent helpers, and
+ * those are not meant to be registered. Only a file that actually default
+ * exports a module is worth warning about; one that default exports something
+ * else is a mistake, because nothing will ever load it.
+ *
+ * See {@link createValModuleFileInspector}.
+ */
+
+/**
+ * Inspects individual `*.val.{ts,js}` files, sharing one module cache and one
+ * parsed tsconfig across every call.
+ *
+ * The default export is checked SYNTACTICALLY first and only evaluated if it is
+ * there. That ordering is the point: a `.val.ts` with no default export is a
+ * helper file, and evaluating it to learn that would be both wasted work and a
+ * way to turn an unrelated top-level throw into a reported error.
+ *
+ * SECURITY: evaluation goes through the same `vm` loader as
+ * {@link loadValModules} — see the warning there. Only ever point this at the
+ * project's own first-party files.
+ */
+function createValModuleFileInspector(projectRoot, host = ts__default["default"].sys) {
+  const compilerOptions = getCompilerOptions(projectRoot, host);
+  const cache = {};
+  return absPath => {
+    const code = host.readFile(absPath);
+    if (code === undefined) {
+      return {
+        status: "invalid",
+        message: `Could not read file: '${absPath}'`
+      };
+    }
+    const sourceFile = ts__default["default"].createSourceFile(absPath, code, ts__default["default"].ScriptTarget.ES2020, true);
+    if (!hasDefaultExport(sourceFile)) {
+      return {
+        status: "no-default-export"
+      };
+    }
+    let exports;
+    // `loadModule` inserts a module into the cache BEFORE evaluating it, so
+    // that a cycle resolves. One that throws therefore leaves a half-built
+    // entry behind - and unlike `loadValModules`, which builds a cache per
+    // call and lets the throw escape, this cache outlives the failure. A later
+    // inspection of the same file (or of the helper that actually threw) would
+    // hit that entry, see empty exports, and report "default export is
+    // undefined" instead of the real error - or, worse, quietly downgrade it to
+    // a warning. So roll the cache back to what it was before this attempt.
+    const before = new Set(Object.keys(cache));
+    try {
+      exports = loadModule(absPath, cache, compilerOptions, host).exports;
+    } catch (e) {
+      for (const key of Object.keys(cache)) {
+        if (!before.has(key)) {
+          delete cache[key];
+        }
+      }
+      return {
+        status: "invalid",
+        message: `Could not be loaded. Error: ${errorMessage(e)}`
+      };
+    }
+    if (core.Internal.isValModule(exports.default)) {
+      return {
+        status: "val-module"
+      };
+    }
+    // NOTE: do NOT suggest wrapping this in `c.define`. A shared schema turned
+    // into a module is an UNREGISTERED module, i.e. straight back to a warning.
+    // The fix is to move it out of the default export slot, which is the one
+    // thing about a `.val.ts` that Val reserves for itself.
+    return {
+      status: "invalid",
+      message: `Default export is ${describeDefaultExport(exports.default)}, not a Val module. Only 'c.define(...)' may be the default export of a '*.val.ts' file: use a named export for a shared schema or helper`
+    };
+  };
+}
+
+/**
+ * Whether the file exports a RUNTIME value as `default`, without evaluating it.
+ *
+ * Two things deliberately do not count, because neither exists once the file is
+ * transpiled — and treating either as a default export would send a pure helper
+ * off to be evaluated and reported:
+ *
+ *  - `export * from "./x"`, since a star re-export never carries the default;
+ *  - a type-only export, in either of its spellings
+ *    (`export type { T as default }` and `export { type T as default }`).
+ */
+function hasDefaultExport(sourceFile) {
+  return sourceFile.statements.some(statement => {
+    // `export default <expr>` — but not `export = x`, which shares this node.
+    if (ts__default["default"].isExportAssignment(statement)) {
+      return !statement.isExportEquals;
+    }
+    // `export { x as default }` / `export { default } from "./x"`
+    if (ts__default["default"].isExportDeclaration(statement) && !statement.isTypeOnly && statement.exportClause && ts__default["default"].isNamedExports(statement.exportClause)) {
+      return statement.exportClause.elements.some(element => !element.isTypeOnly && element.name.text === "default");
+    }
+    // `export default function f() {}` / `export default class C {}`, which are
+    // declarations carrying a `default` modifier rather than export assignments.
+    return ts__default["default"].canHaveModifiers(statement) && (ts__default["default"].getModifiers(statement) ?? []).some(modifier => modifier.kind === ts__default["default"].SyntaxKind.DefaultKeyword);
+  });
+}
+
+/** A short, human-readable "what you exported instead" for the error message. */
+function describeDefaultExport(value) {
+  if (value === null) {
+    return "null";
+  }
+  if (Array.isArray(value)) {
+    return "an array";
+  }
+  if (typeof value === "object") {
+    // Duck-typed rather than `instanceof Schema`, for the same cross-realm
+    // reason `isValModule` avoids a constructor check.
+    if ("executeSerialize" in value && typeof value["executeSerialize"] === "function") {
+      return "a schema";
+    }
+    return "an object";
+  }
+  if (typeof value === "undefined") {
+    return "undefined";
+  }
+  return `a ${typeof value}`;
+}
+function errorMessage(e) {
+  // NOT `e instanceof Error`: an error thrown from inside the `vm` context is
+  // built from that realm's Error constructor. Duck-type the message instead.
+  if (typeof e === "object" && e !== null && "message" in e) {
+    const {
+      message
+    } = e;
+    if (typeof message === "string") {
+      return message;
+    }
+  }
+  return String(e);
+}
+
 const jsonOps$1 = new patch.JSONOps();
 
 /**
@@ -12531,6 +12675,7 @@ exports.createJsonEntryPathMap = createJsonEntryPathMap;
 exports.createModulePathMap = createModulePathMap;
 exports.createService = createService;
 exports.createValApiRouter = createValApiRouter;
+exports.createValModuleFileInspector = createValModuleFileInspector;
 exports.createValServer = createValServer;
 exports.currentFixHandlers = currentFixHandlers;
 exports.decodeJwt = decodeJwt;

package/dist/valbuild-server.esm.js

@@ -1,7 +1,7 @@
 import ts from 'typescript';
 import { pipe, result, array } from '@valbuild/core/fp';
 import { PatchError, deepEqual, parseAndValidateArrayIndex, isNotRoot, applyPatch, JSONOps, deepClone, sourceToPatchPath } from '@valbuild/core/patch';
-import { derefPatch, RecordSchema, Internal, extractValModules, computeValModuleShas, VAL_EXTENSION, ImageSchema, DEFAULT_CONTENT_HOST, hasRemoteFileSchema } from '@valbuild/core';
+import { derefPatch, Internal, RecordSchema, extractValModules, computeValModuleShas, VAL_EXTENSION, ImageSchema, DEFAULT_CONTENT_HOST, hasRemoteFileSchema } from '@valbuild/core';
 export { hasRemoteFileSchema } from '@valbuild/core';
 import * as path from 'path';
 import path__default from 'path';
@@ -862,6 +862,150 @@ function resolveRelative(dirName, spec, host) {
   return null;
 }
 
+/**
+ * What a `*.val.ts` file that is NOT registered in `val.modules` turns out to
+ * be.
+ *
+ * A file matching `*.val.ts` is not necessarily a Val module: the same
+ * convention is used for shared schemas and other content-adjacent helpers, and
+ * those are not meant to be registered. Only a file that actually default
+ * exports a module is worth warning about; one that default exports something
+ * else is a mistake, because nothing will ever load it.
+ *
+ * See {@link createValModuleFileInspector}.
+ */
+
+/**
+ * Inspects individual `*.val.{ts,js}` files, sharing one module cache and one
+ * parsed tsconfig across every call.
+ *
+ * The default export is checked SYNTACTICALLY first and only evaluated if it is
+ * there. That ordering is the point: a `.val.ts` with no default export is a
+ * helper file, and evaluating it to learn that would be both wasted work and a
+ * way to turn an unrelated top-level throw into a reported error.
+ *
+ * SECURITY: evaluation goes through the same `vm` loader as
+ * {@link loadValModules} — see the warning there. Only ever point this at the
+ * project's own first-party files.
+ */
+function createValModuleFileInspector(projectRoot, host = ts.sys) {
+  const compilerOptions = getCompilerOptions(projectRoot, host);
+  const cache = {};
+  return absPath => {
+    const code = host.readFile(absPath);
+    if (code === undefined) {
+      return {
+        status: "invalid",
+        message: `Could not read file: '${absPath}'`
+      };
+    }
+    const sourceFile = ts.createSourceFile(absPath, code, ts.ScriptTarget.ES2020, true);
+    if (!hasDefaultExport(sourceFile)) {
+      return {
+        status: "no-default-export"
+      };
+    }
+    let exports;
+    // `loadModule` inserts a module into the cache BEFORE evaluating it, so
+    // that a cycle resolves. One that throws therefore leaves a half-built
+    // entry behind - and unlike `loadValModules`, which builds a cache per
+    // call and lets the throw escape, this cache outlives the failure. A later
+    // inspection of the same file (or of the helper that actually threw) would
+    // hit that entry, see empty exports, and report "default export is
+    // undefined" instead of the real error - or, worse, quietly downgrade it to
+    // a warning. So roll the cache back to what it was before this attempt.
+    const before = new Set(Object.keys(cache));
+    try {
+      exports = loadModule(absPath, cache, compilerOptions, host).exports;
+    } catch (e) {
+      for (const key of Object.keys(cache)) {
+        if (!before.has(key)) {
+          delete cache[key];
+        }
+      }
+      return {
+        status: "invalid",
+        message: `Could not be loaded. Error: ${errorMessage(e)}`
+      };
+    }
+    if (Internal.isValModule(exports.default)) {
+      return {
+        status: "val-module"
+      };
+    }
+    // NOTE: do NOT suggest wrapping this in `c.define`. A shared schema turned
+    // into a module is an UNREGISTERED module, i.e. straight back to a warning.
+    // The fix is to move it out of the default export slot, which is the one
+    // thing about a `.val.ts` that Val reserves for itself.
+    return {
+      status: "invalid",
+      message: `Default export is ${describeDefaultExport(exports.default)}, not a Val module. Only 'c.define(...)' may be the default export of a '*.val.ts' file: use a named export for a shared schema or helper`
+    };
+  };
+}
+
+/**
+ * Whether the file exports a RUNTIME value as `default`, without evaluating it.
+ *
+ * Two things deliberately do not count, because neither exists once the file is
+ * transpiled — and treating either as a default export would send a pure helper
+ * off to be evaluated and reported:
+ *
+ *  - `export * from "./x"`, since a star re-export never carries the default;
+ *  - a type-only export, in either of its spellings
+ *    (`export type { T as default }` and `export { type T as default }`).
+ */
+function hasDefaultExport(sourceFile) {
+  return sourceFile.statements.some(statement => {
+    // `export default <expr>` — but not `export = x`, which shares this node.
+    if (ts.isExportAssignment(statement)) {
+      return !statement.isExportEquals;
+    }
+    // `export { x as default }` / `export { default } from "./x"`
+    if (ts.isExportDeclaration(statement) && !statement.isTypeOnly && statement.exportClause && ts.isNamedExports(statement.exportClause)) {
+      return statement.exportClause.elements.some(element => !element.isTypeOnly && element.name.text === "default");
+    }
+    // `export default function f() {}` / `export default class C {}`, which are
+    // declarations carrying a `default` modifier rather than export assignments.
+    return ts.canHaveModifiers(statement) && (ts.getModifiers(statement) ?? []).some(modifier => modifier.kind === ts.SyntaxKind.DefaultKeyword);
+  });
+}
+
+/** A short, human-readable "what you exported instead" for the error message. */
+function describeDefaultExport(value) {
+  if (value === null) {
+    return "null";
+  }
+  if (Array.isArray(value)) {
+    return "an array";
+  }
+  if (typeof value === "object") {
+    // Duck-typed rather than `instanceof Schema`, for the same cross-realm
+    // reason `isValModule` avoids a constructor check.
+    if ("executeSerialize" in value && typeof value["executeSerialize"] === "function") {
+      return "a schema";
+    }
+    return "an object";
+  }
+  if (typeof value === "undefined") {
+    return "undefined";
+  }
+  return `a ${typeof value}`;
+}
+function errorMessage(e) {
+  // NOT `e instanceof Error`: an error thrown from inside the `vm` context is
+  // built from that realm's Error constructor. Duck-type the message instead.
+  if (typeof e === "object" && e !== null && "message" in e) {
+    const {
+      message
+    } = e;
+    if (typeof message === "string") {
+      return message;
+    }
+  }
+  return String(e);
+}
+
 const jsonOps$1 = new JSONOps();
 
 /**
@@ -12473,4 +12617,4 @@ function readCapturedReport(snapshotDir) {
   return JSON.parse(fs.readFileSync(reportPath, "utf-8"));
 }
 
-export { DEFAULT_LOGIN_HOST, DEFAULT_LOGIN_MAX_DURATION, DEFAULT_LOGIN_POLL_INTERVAL, Service, ValFSHost, ValLoginError, ValModuleLoader, ValOpsFS, ValOpsHttp, ValSourceFileHandler, analyzeValModule, awaitValLoginConfirmation, checkRemoteRef, compareWithCapturedReport, createDefaultValFSHost, createFixPatch, createJsonEntryPathMap, createModulePathMap, createService, createValApiRouter, createValServer, currentFixHandlers, decodeJwt, describePatchStoreProblems, downloadFileFromRemote, encodeJwt, evalValConfigFile, extractFileMetadata, extractImageMetadata, extractJsonValuesEntry, findAndEvalValConfigFile, findJsonEntryFilePath, fixHandlers, formatPatchSourceError, formatSyntaxErrorTree, getCachedRemoteFileDir, getCachedRemoteFilePath, getCompilerOptions, getExpire, getFileExt, getModulePathRange, getPersonalAccessTokenPath, getSettings, getValidationErrorFileRef, handleCheckAllFiles, handleFileMetadata, handleJsonValuesExtractEntry, handleRemoteFileCheck, handleRemoteFileDownload, handleRemoteFileUpload, handleRemoteGalleryFileUpload, handleUniqueFolderCheck, loadValModules, parsePersonalAccessTokenFile, patchSourceFile, persistPersonalAccessToken, readCapturedReport, readPatchStore, replaySnapshot, safeReadGit, startValLogin, uploadRemoteFile, validateMetadata };
+export { DEFAULT_LOGIN_HOST, DEFAULT_LOGIN_MAX_DURATION, DEFAULT_LOGIN_POLL_INTERVAL, Service, ValFSHost, ValLoginError, ValModuleLoader, ValOpsFS, ValOpsHttp, ValSourceFileHandler, analyzeValModule, awaitValLoginConfirmation, checkRemoteRef, compareWithCapturedReport, createDefaultValFSHost, createFixPatch, createJsonEntryPathMap, createModulePathMap, createService, createValApiRouter, createValModuleFileInspector, createValServer, currentFixHandlers, decodeJwt, describePatchStoreProblems, downloadFileFromRemote, encodeJwt, evalValConfigFile, extractFileMetadata, extractImageMetadata, extractJsonValuesEntry, findAndEvalValConfigFile, findJsonEntryFilePath, fixHandlers, formatPatchSourceError, formatSyntaxErrorTree, getCachedRemoteFileDir, getCachedRemoteFilePath, getCompilerOptions, getExpire, getFileExt, getModulePathRange, getPersonalAccessTokenPath, getSettings, getValidationErrorFileRef, handleCheckAllFiles, handleFileMetadata, handleJsonValuesExtractEntry, handleRemoteFileCheck, handleRemoteFileDownload, handleRemoteFileUpload, handleRemoteGalleryFileUpload, handleUniqueFolderCheck, loadValModules, parsePersonalAccessTokenFile, patchSourceFile, persistPersonalAccessToken, readCapturedReport, readPatchStore, replaySnapshot, safeReadGit, startValLogin, uploadRemoteFile, validateMetadata };

package/package.json

@@ -16,7 +16,7 @@
     "./package.json": "./package.json"
   },
   "types": "dist/valbuild-server.cjs.d.ts",
-  "version": "0.105.1",
+  "version": "0.106.0",
   "devDependencies": {
     "@prettier/sync": "^0.6.1",
     "@types/jest": "^30.0.0"
@@ -24,13 +24,13 @@
   "dependencies": {
     "chokidar": "^5.0.0",
     "image-size": "^2.0.2",
-    "minimatch": "^10.1.1",
+    "minimatch": "^10.2.3",
     "sucrase": "^3.35.1",
     "typescript": "^5.9.3",
     "zod": "^4.3.5",
     "zod-validation-error": "^5.0.0",
-    "@valbuild/core": "0.105.1",
-    "@valbuild/shared": "0.105.1",
+    "@valbuild/core": "0.106.0",
+    "@valbuild/shared": "0.106.0",
     "@valbuild/ui": "0.105.1"
   },
   "engines": {