@salty-css/core 0.1.0-refactor-add-additional-paths-to-config-cache.1 → 0.1.0

package/parsers/index.js

@@ -1,10 +1,41 @@
-import { p as parseAndJoinStyles } from "../parse-styles-CLMTHo2H.js";
-import { a, c, d, b, r } from "../parse-styles-CLMTHo2H.js";
-import { d as dashCase } from "../dash-case-DblXvymC.js";
-import { t as toHash } from "../to-hash-DAN2LcHK.js";
+import { i as isRichTemplateNode, p as parseAndJoinStyles } from "../parse-styles-BgVqQAni.js";
+import { a, d, e, c, r } from "../parse-styles-BgVqQAni.js";
+import { d as dashCase, t as toHash } from "../to-hash-DSoCPs8D.js";
+const RICH_META_KEYS = /* @__PURE__ */ new Set(["base", "variants", "defaultVariants", "compoundVariants", "anyOfVariants"]);
+const isChildEntry = (key, value) => {
+  if (RICH_META_KEYS.has(key)) return false;
+  return !!value && typeof value === "object" && !Array.isArray(value);
+};
 const parseTemplates = async (obj, path = []) => {
   if (!obj) return "";
   const classes = [];
+  if (isRichTemplateNode(obj)) {
+    const rich = obj;
+    const baseClassName = path.map((p) => dashCase(String(p))).join("-");
+    if (rich.base) {
+      const hashClass = "t_" + toHash(baseClassName, 4);
+      const result = await parseAndJoinStyles(rich.base, `.${baseClassName}, .${hashClass}`);
+      classes.push(result);
+    }
+    if (rich.variants) {
+      for (const [axis, valueMap] of Object.entries(rich.variants)) {
+        if (!valueMap || typeof valueMap !== "object") continue;
+        for (const [value, styles] of Object.entries(valueMap)) {
+          if (!styles || typeof styles !== "object") continue;
+          const variantClassName = `${baseClassName}-${dashCase(axis)}-${dashCase(value)}`;
+          const variantHashClass = "tv_" + toHash(variantClassName, 4);
+          const result = await parseAndJoinStyles(styles, `.${variantClassName}, .${variantHashClass}`);
+          classes.push(result);
+        }
+      }
+    }
+    for (const [key, value] of Object.entries(rich)) {
+      if (!isChildEntry(key, value)) continue;
+      const result = await parseTemplates(value, [...path, key.trim()]);
+      classes.push(result);
+    }
+    return classes.join("\n");
+  }
   const levelStyles = {};
   for (const [key, value] of Object.entries(obj)) {
     if (typeof value === "function") ;
@@ -17,7 +48,7 @@ const parseTemplates = async (obj, path = []) => {
     }
   }
   if (Object.keys(levelStyles).length) {
-    const className = path.map(dashCase).join("-");
+    const className = path.map((p) => dashCase(String(p))).join("-");
     const hashClass = "t_" + toHash(className, 4);
     const result = await parseAndJoinStyles(levelStyles, `.${className}, .${hashClass}`);
     classes.push(result);
@@ -39,22 +70,79 @@ const getTemplateTypes = (templates) => {
 };
 const getTemplateTokens = (templates, parent = "", templateTokens = /* @__PURE__ */ new Set()) => {
   if (!templates) return [];
+  if (isRichTemplateNode(templates)) {
+    if (parent) templateTokens.add(parent);
+    Object.entries(templates).forEach(([key, value]) => {
+      if (!isChildEntry(key, value)) return;
+      const keyValue = parent ? `${parent}.${key}` : key;
+      getTemplateTokens(value, keyValue, templateTokens);
+    });
+    return [...templateTokens];
+  }
   Object.entries(templates).forEach(([key, value]) => {
     const keyValue = parent ? `${parent}.${key}` : key;
-    if (typeof value === "object") return getTemplateTokens(value, keyValue, templateTokens);
+    if (value && typeof value === "object") return getTemplateTokens(value, keyValue, templateTokens);
     return templateTokens.add(parent);
   });
   return [...templateTokens];
 };
+const getTemplateVariantMaps = (templates) => {
+  const result = {};
+  if (!templates) return result;
+  for (const [topKey, topNode] of Object.entries(templates)) {
+    if (!topNode || typeof topNode !== "object" || typeof topNode === "function") continue;
+    walk(topNode, [], result[topKey] || (result[topKey] = {}), {});
+  }
+  return result;
+};
+const mergeAxes = (inherited, node) => {
+  const next = {};
+  for (const [axis, vals] of Object.entries(inherited)) {
+    next[axis] = { ...vals };
+  }
+  if (isRichTemplateNode(node) && node.variants) {
+    for (const [axis, valueMap] of Object.entries(node.variants)) {
+      next[axis] = next[axis] || {};
+      for (const value of Object.keys(valueMap)) next[axis][value] = true;
+    }
+  }
+  return next;
+};
+const walk = (node, path, out, inheritedAxes) => {
+  if (!node || typeof node !== "object" || Array.isArray(node)) return;
+  const axes = mergeAxes(inheritedAxes, node);
+  const dot = path.join(".");
+  if (path.length && (isRichTemplateNode(node) || Object.keys(axes).length)) {
+    const axisMap = {};
+    for (const [axis, valSet] of Object.entries(axes)) {
+      const values = Object.keys(valSet);
+      const isBooleanOnly = values.length === 1 && values[0] === "true";
+      axisMap[axis] = isBooleanOnly ? "boolean" : values.map((v) => `"${v}"`).join(" | ");
+    }
+    if (Object.keys(axisMap).length) out[dot] = axisMap;
+  }
+  if (isRichTemplateNode(node)) {
+    for (const [key, value] of Object.entries(node)) {
+      if (!isChildEntry(key, value)) continue;
+      walk(value, [...path, key.trim()], out, axes);
+    }
+    return;
+  }
+  for (const [key, value] of Object.entries(node)) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) continue;
+    walk(value, [...path, key.trim()], out, axes);
+  }
+};
 export {
   getTemplateKeys,
   getTemplateTokens,
   getTemplateTypes,
+  getTemplateVariantMaps,
   parseAndJoinStyles,
   a as parseStyles,
   parseTemplates,
-  c as parseValueModifiers,
-  d as parseValueTokens,
-  b as parseVariableTokens,
+  d as parseValueModifiers,
+  e as parseValueTokens,
+  c as parseVariableTokens,
   r as reportParserIssue
 };

package/parsers/parse-templates.d.ts

@@ -2,3 +2,13 @@ export declare const parseTemplates: <T extends object>(obj: T, path?: PropertyK
 export declare const getTemplateKeys: <T extends object>(templates: T) => string[];
 export declare const getTemplateTypes: <T extends object>(templates: T) => Record<string, string>;
 export declare const getTemplateTokens: <T extends object>(templates: T, parent?: string, templateTokens?: Set<string>) => string[];
+/**
+ * Walk every rich-template path in a templates root and emit, for each reachable dot-path, the set of
+ * variant axes valid at that path (axis name → union of value names, with `boolean` for axes whose only
+ * declared value is `true`).
+ *
+ * Inheritance: a leaf's axis enum is the union of its own values and every ancestor's values for the
+ * same axis. Matches the resolver's bottom-up lookup semantics — anything reachable via fallback is a
+ * valid call-site value.
+ */
+export declare const getTemplateVariantMaps: (templates: Record<string, any>) => Record<string, Record<string, Record<string, string>>>;

package/parsers/parser-regexes.d.ts

@@ -1,3 +1,4 @@
 export declare const pseudoTypoRegex: RegExp;
 export declare const templateLiteralLeftoverRegex: RegExp;
 export declare const bareAtRuleRegex: RegExp;
+export declare const keyframesAtRuleRegex: RegExp;

package/parsers/resolve-template-variants.d.ts

@@ -0,0 +1,21 @@
+import { RichTemplateNode } from '../types/config-types';
+export type TemplateCallSite = {
+    path: string[];
+    variants: Record<string, string | boolean>;
+};
+export declare const isRichTemplateNode: (node: unknown) => node is RichTemplateNode;
+/**
+ * Parse a template call-site value into its dot-path and the axis values requested at the call site.
+ *
+ * String form:  `'heading.large@weight=heavy&emphasis=loud&italic'`
+ * Object form:  `{ name: 'heading.large', weight: 'heavy', emphasis: 'loud', italic: true }`
+ */
+export declare const parseTemplateCallSite: (value: unknown) => TemplateCallSite | undefined;
+export declare const pathHasRichNode: (root: any, path: string[]) => boolean;
+/**
+ * Resolve a rich-template invocation into a flat CSS-in-JS object.
+ * Implements docs/template-variants-spec.md §5 (parent-to-leaf inheritance, replace semantics).
+ *
+ * Returns `undefined` if the path doesn't resolve. Emits console.warn for unknown axes / values.
+ */
+export declare const resolveRichTemplate: (root: any, path: string[], callSiteVariants: Record<string, string | boolean>, templateName: string) => Record<string, any> | undefined;

package/runtime/index.cjs

@@ -1,11 +1,24 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const parseStyles = require("../parse-styles-C54MOrPg.cjs");
+const parseStyles = require("../parse-styles-BbI-2wdn.cjs");
+const toHash = require("../to-hash-DT2ImSPA.cjs");
 const defineRuntime = (config) => {
-  const getDynamicStylesCss = async (styles, scope) => {
+  const className = (styles) => toHash.toHash(styles);
+  const css = async (styles, scope) => {
     const parsed = await parseStyles.parseStyles(styles, scope, config);
     return parsed.join("\n");
   };
-  return { getDynamicStylesCss };
+  const resolve = async (styles, scope) => {
+    const _className = className(styles);
+    const _css = await css(styles, scope || `.${_className}`);
+    return { className: _className, css: _css };
+  };
+  return {
+    className,
+    css,
+    resolve,
+    /** @deprecated Use `css` instead. Kept as an alias for backward compatibility with the standalone `getDynamicStylesCss` helper. */
+    getDynamicStylesCss: css
+  };
 };
 exports.defineRuntime = defineRuntime;

package/runtime/index.d.ts

@@ -2,6 +2,13 @@ import { CachedConfig, SaltyConfig } from '../config';
 import { BaseStyles } from '../types';
 type Config = Partial<SaltyConfig & CachedConfig>;
 export declare const defineRuntime: (config: Config) => {
+    className: (styles: BaseStyles) => string;
+    css: (styles: BaseStyles, scope?: string) => Promise<string>;
+    resolve: (styles: BaseStyles, scope?: string) => Promise<{
+        className: string;
+        css: string;
+    }>;
+    /** @deprecated Use `css` instead. Kept as an alias for backward compatibility with the standalone `getDynamicStylesCss` helper. */
     getDynamicStylesCss: (styles: BaseStyles, scope?: string) => Promise<string>;
 };
 export {};

package/runtime/index.js

@@ -1,10 +1,23 @@
-import { a as parseStyles } from "../parse-styles-CLMTHo2H.js";
+import { a as parseStyles } from "../parse-styles-BgVqQAni.js";
+import { t as toHash } from "../to-hash-DSoCPs8D.js";
 const defineRuntime = (config) => {
-  const getDynamicStylesCss = async (styles, scope) => {
+  const className = (styles) => toHash(styles);
+  const css = async (styles, scope) => {
     const parsed = await parseStyles(styles, scope, config);
     return parsed.join("\n");
   };
-  return { getDynamicStylesCss };
+  const resolve = async (styles, scope) => {
+    const _className = className(styles);
+    const _css = await css(styles, scope || `.${_className}`);
+    return { className: _className, css: _css };
+  };
+  return {
+    className,
+    css,
+    resolve,
+    /** @deprecated Use `css` instead. Kept as an alias for backward compatibility with the standalone `getDynamicStylesCss` helper. */
+    getDynamicStylesCss: css
+  };
 };
 export {
   defineRuntime

package/{to-hash-DAN2LcHK.js → to-hash-DSoCPs8D.js}

@@ -1,3 +1,10 @@
+function dashCase(str) {
+  if (!str) return "";
+  if (typeof str !== "string") return dashCase(String(str));
+  return str.replace(/[\s.]/g, "-").replace(/[A-Z](?:(?=[^A-Z])|[A-Z]*(?=[A-Z][^A-Z]|$))/g, (s, i) => {
+    return (i > 0 ? "-" : "") + s.toLowerCase();
+  });
+}
 const toAlphabeticChar = (code) => String.fromCharCode(code + (code > 25 ? 39 : 97));
 const toAlphabeticName = (code, length) => {
   let name = "";
@@ -21,5 +28,6 @@ const toHash = (value, length = 5) => {
   return toAlphabeticName(numericHash, length);
 };
 export {
+  dashCase as d,
   toHash as t
 };

package/{to-hash-C05Y906F.cjs → to-hash-DT2ImSPA.cjs}

@@ -1,4 +1,11 @@
 "use strict";
+function dashCase(str) {
+  if (!str) return "";
+  if (typeof str !== "string") return dashCase(String(str));
+  return str.replace(/[\s.]/g, "-").replace(/[A-Z](?:(?=[^A-Z])|[A-Z]*(?=[A-Z][^A-Z]|$))/g, (s, i) => {
+    return (i > 0 ? "-" : "") + s.toLowerCase();
+  });
+}
 const toAlphabeticChar = (code) => String.fromCharCode(code + (code > 25 ? 39 : 97));
 const toAlphabeticName = (code, length) => {
   let name = "";
@@ -21,4 +28,5 @@ const toHash = (value, length = 5) => {
   const numericHash = toPhash(5381, JSON.stringify(value)) >>> 0;
   return toAlphabeticName(numericHash, length);
 };
+exports.dashCase = dashCase;
 exports.toHash = toHash;

package/types/config-types.d.ts

@@ -1,5 +1,6 @@
 import { BaseStyles, CssStyles, MediaQueryStyles } from '../types';
 import { OrString } from '../types/util-types';
+export * from './font-types';
 export type GlobalStyles = Record<string, BaseStyles>;
 export type CssVariableTokensObject = Record<string, unknown>;
 export interface CssResponsiveVariables {
@@ -15,7 +16,38 @@ export interface SaltyVariables {
     conditional?: CssConditionalVariables;
     [key: string]: undefined | string | number | CssVariableTokensObject;
 }
-type CssTemplate = MediaQueryStyles | CssStyles | {
+/**
+ * A variant axis value bundle: a map from axis name to a map from value name (string keys or `'true'`)
+ * to a CSS-in-JS block. `name` is reserved as the call-site object form's path key and cannot be used
+ * as an axis name (build-time error).
+ */
+export type CssVariantAxes = {
+    [axis: string]: {
+        [value: string]: CssStyles;
+    };
+} & {
+    name?: never;
+};
+export interface CssCompoundVariant {
+    css: CssStyles;
+    [axis: string]: any;
+}
+/**
+ * A "rich" template node: declares its own base styles, named variant bundles, defaults, and compound rules.
+ * May coexist with child template nodes (descendants) as additional sibling keys.
+ */
+export type RichTemplateNode = {
+    base?: CssStyles;
+    variants?: CssVariantAxes;
+    defaultVariants?: {
+        [axis: string]: string | boolean;
+    };
+    compoundVariants?: CssCompoundVariant[];
+    anyOfVariants?: CssCompoundVariant[];
+} & {
+    [key: PropertyKey]: any;
+};
+type CssTemplate = MediaQueryStyles | CssStyles | RichTemplateNode | {
     [key: PropertyKey]: CssTemplate;
 };
 export interface CssTemplateObject {
@@ -91,4 +123,3 @@ export interface CachedConfig {
         [key: string]: string;
     };
 }
-export {};

package/types/font-types.d.ts

@@ -0,0 +1,53 @@
+export type FontDisplay = 'auto' | 'block' | 'swap' | 'fallback' | 'optional';
+export type FontFormat = 'woff2' | 'woff' | 'truetype' | 'opentype' | 'embedded-opentype' | 'svg' | 'collection';
+export type FontStyle = 'normal' | 'italic' | 'oblique' | (string & {});
+export type FontWeight = number | 'normal' | 'bold' | 'lighter' | 'bolder' | (string & {});
+export interface FontSrc {
+    url: string;
+    format?: FontFormat;
+    /** Optional `tech(...)` descriptor passed straight through to @font-face. */
+    tech?: string;
+}
+export interface FontVariant {
+    weight?: FontWeight;
+    style?: FontStyle;
+    stretch?: string;
+    display?: FontDisplay;
+    unicodeRange?: string;
+    ascentOverride?: string;
+    descentOverride?: string;
+    lineGapOverride?: string;
+    sizeAdjust?: string;
+    /**
+     * One or more font sources. Strings are treated as URLs and the `format()`
+     * descriptor is auto-detected from the file extension when possible. Use
+     * the `{ url, format }` object form for CDN/extensionless URLs where the
+     * format must be set explicitly.
+     */
+    src: string | FontSrc | (string | FontSrc)[];
+}
+interface DefineFontBase {
+    /** CSS `font-family` value users will see in styles. */
+    name: string;
+    /**
+     * CSS variable name. Accepts `--font-inter` or `font-inter`; we normalize.
+     * Optional — when omitted, a deterministic name is derived from the other
+     * inputs as `--font-<name>-<hash>`.
+     */
+    variable?: string;
+    /** Default `font-display` applied to variants that don't set their own. */
+    display?: FontDisplay;
+    /** Family fallback(s) appended after `name` in the generated `font-family` string. */
+    fallback?: string;
+}
+export interface DefineFontVariantsOptions extends DefineFontBase {
+    variants: FontVariant[];
+    import?: never;
+}
+export interface DefineFontImportOptions extends DefineFontBase {
+    /** Remote stylesheet URL (e.g. Google Fonts). Emitted as `@import url(...)`. */
+    import: string;
+    variants?: never;
+}
+export type DefineFontOptions = DefineFontVariantsOptions | DefineFontImportOptions;
+export {};

package/util/index.cjs

@@ -1,14 +1,13 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const dashCase = require("../dash-case-DIwKaYgE.cjs");
+const toHash = require("../to-hash-DT2ImSPA.cjs");
 const pascalCase = require("../pascal-case-By_l58S-.cjs");
-const toHash = require("../to-hash-C05Y906F.cjs");
 function camelCase(str) {
   if (!str) return "";
   if (typeof str !== "string") return camelCase(String(str));
   return str.replace(/\s/g, "-").replace(/-([a-z])/g, (g) => g[1].toUpperCase());
 }
-exports.dashCase = dashCase.dashCase;
-exports.pascalCase = pascalCase.pascalCase;
+exports.dashCase = toHash.dashCase;
 exports.toHash = toHash.toHash;
+exports.pascalCase = pascalCase.pascalCase;
 exports.camelCase = camelCase;

package/util/index.js

@@ -1,6 +1,5 @@
-import { d } from "../dash-case-DblXvymC.js";
+import { d, t } from "../to-hash-DSoCPs8D.js";
 import { p } from "../pascal-case-F3Usi5Wf.js";
-import { t } from "../to-hash-DAN2LcHK.js";
 function camelCase(str) {
   if (!str) return "";
   if (typeof str !== "string") return camelCase(String(str));

package/util/module-type.d.ts

@@ -1 +1 @@
-export declare const detectCurrentModuleType: (dirname: string) => Promise<"esm" | "cjs">;
+export declare const detectCurrentModuleType: (dirname: string) => Promise<"cjs" | "esm">;

package/cache/resolve-dynamic-config-cache.cjs

@@ -1,64 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const promises = require("fs/promises");
-const path = require("path");
-const CACHE_FILENAME = "config-cache.json";
-const ENV_VAR = "SALTY_CONFIG_CACHE_PATH";
-const defaultRoots = ["", "src", "dist", "build", "public", ".next", ".next/server", ".vercel/output/functions"];
-const memo = /* @__PURE__ */ new Map();
-let warned = false;
-const isProduction = () => {
-  try {
-    return process.env["NODE_ENV"] === "production";
-  } catch {
-    return false;
-  }
-};
-const toAbsolute = (p, cwd) => path.isAbsolute(p) ? p : path.join(cwd, p);
-const candidatePathsFrom = (entry, cwd) => {
-  const abs = toAbsolute(entry, cwd);
-  if (abs.endsWith(".json")) return [abs];
-  return [path.join(abs, CACHE_FILENAME), path.join(abs, "cache", CACHE_FILENAME), path.join(abs, "saltygen", "cache", CACHE_FILENAME)];
-};
-const tryRead = async (path2) => {
-  const useMemo = isProduction();
-  if (useMemo && memo.has(path2)) return memo.get(path2) ?? void 0;
-  try {
-    const contents = await promises.readFile(path2, "utf8");
-    if (!contents) {
-      if (useMemo) memo.set(path2, null);
-      return void 0;
-    }
-    const parsed = JSON.parse(contents);
-    if (useMemo) memo.set(path2, parsed);
-    return parsed;
-  } catch {
-    if (useMemo) memo.set(path2, null);
-    return void 0;
-  }
-};
-const resolveDynamicConfigCache = async (options = {}) => {
-  var _a;
-  const cwd = options.cwd ?? process.cwd();
-  const envPath = typeof process !== "undefined" ? (_a = process.env) == null ? void 0 : _a[ENV_VAR] : void 0;
-  const ordered = [];
-  if (options.primaryPath) ordered.push(...candidatePathsFrom(options.primaryPath, cwd));
-  if (envPath) ordered.push(...candidatePathsFrom(envPath, cwd));
-  if (options.extraPaths) for (const p of options.extraPaths) ordered.push(...candidatePathsFrom(p, cwd));
-  for (const root of defaultRoots) ordered.push(...candidatePathsFrom(root, cwd));
-  for (const candidate of ordered) {
-    const result = await tryRead(candidate);
-    if (result) return result;
-  }
-  if (!warned) {
-    warned = true;
-    console.warn(`Could not find config cache file (${CACHE_FILENAME}) in any of the expected locations.`);
-  }
-  return {};
-};
-const _resetDynamicConfigCacheMemo = () => {
-  memo.clear();
-  warned = false;
-};
-exports._resetDynamicConfigCacheMemo = _resetDynamicConfigCacheMemo;
-exports.resolveDynamicConfigCache = resolveDynamicConfigCache;

package/cache/resolve-dynamic-config-cache.d.ts

@@ -1,20 +0,0 @@
-export interface ResolveDynamicConfigCacheOptions {
-    /**
-     * Highest-priority path checked first. If it resolves, no other paths are tried.
-     * Absolute, or relative to `cwd`.
-     */
-    primaryPath?: string;
-    /**
-     * Extra paths checked before the built-in defaults. Absolute, or relative to `cwd`.
-     */
-    extraPaths?: string[];
-    /**
-     * Base directory for resolving relative paths. Defaults to `process.cwd()`.
-     */
-    cwd?: string;
-}
-export declare const resolveDynamicConfigCache: (options?: ResolveDynamicConfigCacheOptions) => Promise<Record<string, unknown>>;
-/**
- * Clear the in-memory cache of parsed config-cache.json files. Test-only.
- */
-export declare const _resetDynamicConfigCacheMemo: () => void;

package/cache/resolve-dynamic-config-cache.js

@@ -1,64 +0,0 @@
-import { readFile } from "fs/promises";
-import { join, isAbsolute } from "path";
-const CACHE_FILENAME = "config-cache.json";
-const ENV_VAR = "SALTY_CONFIG_CACHE_PATH";
-const defaultRoots = ["", "src", "dist", "build", "public", ".next", ".next/server", ".vercel/output/functions"];
-const memo = /* @__PURE__ */ new Map();
-let warned = false;
-const isProduction = () => {
-  try {
-    return process.env["NODE_ENV"] === "production";
-  } catch {
-    return false;
-  }
-};
-const toAbsolute = (p, cwd) => isAbsolute(p) ? p : join(cwd, p);
-const candidatePathsFrom = (entry, cwd) => {
-  const abs = toAbsolute(entry, cwd);
-  if (abs.endsWith(".json")) return [abs];
-  return [join(abs, CACHE_FILENAME), join(abs, "cache", CACHE_FILENAME), join(abs, "saltygen", "cache", CACHE_FILENAME)];
-};
-const tryRead = async (path) => {
-  const useMemo = isProduction();
-  if (useMemo && memo.has(path)) return memo.get(path) ?? void 0;
-  try {
-    const contents = await readFile(path, "utf8");
-    if (!contents) {
-      if (useMemo) memo.set(path, null);
-      return void 0;
-    }
-    const parsed = JSON.parse(contents);
-    if (useMemo) memo.set(path, parsed);
-    return parsed;
-  } catch {
-    if (useMemo) memo.set(path, null);
-    return void 0;
-  }
-};
-const resolveDynamicConfigCache = async (options = {}) => {
-  var _a;
-  const cwd = options.cwd ?? process.cwd();
-  const envPath = typeof process !== "undefined" ? (_a = process.env) == null ? void 0 : _a[ENV_VAR] : void 0;
-  const ordered = [];
-  if (options.primaryPath) ordered.push(...candidatePathsFrom(options.primaryPath, cwd));
-  if (envPath) ordered.push(...candidatePathsFrom(envPath, cwd));
-  if (options.extraPaths) for (const p of options.extraPaths) ordered.push(...candidatePathsFrom(p, cwd));
-  for (const root of defaultRoots) ordered.push(...candidatePathsFrom(root, cwd));
-  for (const candidate of ordered) {
-    const result = await tryRead(candidate);
-    if (result) return result;
-  }
-  if (!warned) {
-    warned = true;
-    console.warn(`Could not find config cache file (${CACHE_FILENAME}) in any of the expected locations.`);
-  }
-  return {};
-};
-const _resetDynamicConfigCacheMemo = () => {
-  memo.clear();
-  warned = false;
-};
-export {
-  _resetDynamicConfigCacheMemo,
-  resolveDynamicConfigCache
-};

package/compiler/copy-config-cache.cjs

@@ -1,39 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const promises = require("fs/promises");
-const path = require("path");
-const logger = require("../logger-7xz0pyAz.cjs");
-const DEFAULT_SUBPATH = path.join("saltygen", "cache", "config-cache.json");
-const resolveCopyConfigCacheDestinations = (option, defaultOutDir, cwd = process.cwd()) => {
-  if (option === false) return [];
-  const userPaths = [];
-  if (typeof option === "string") userPaths.push(option);
-  else if (Array.isArray(option)) userPaths.push(...option);
-  const destinations = [];
-  const useDefault = option === void 0 || option === true;
-  if (useDefault && defaultOutDir) destinations.push(defaultOutDir);
-  destinations.push(...userPaths);
-  return destinations.map((entry) => {
-    const abs = path.isAbsolute(entry) ? entry : path.resolve(cwd, entry);
-    if (abs.endsWith(".json")) return abs;
-    return path.join(abs, DEFAULT_SUBPATH);
-  });
-};
-const copyConfigCacheTo = async (compiler, destinations) => {
-  if (destinations.length === 0) return;
-  const source = await compiler.getConfigCachePath();
-  await Promise.all(
-    destinations.map(async (destination) => {
-      if (destination === source) return;
-      try {
-        await promises.mkdir(path.dirname(destination), { recursive: true });
-        await promises.copyFile(source, destination);
-        logger.logger.info(`Copied Salty config cache → ${destination}`);
-      } catch (error) {
-        logger.logger.warn(`Failed to copy Salty config cache to ${destination}: ${error.message}`);
-      }
-    })
-  );
-};
-exports.copyConfigCacheTo = copyConfigCacheTo;
-exports.resolveCopyConfigCacheDestinations = resolveCopyConfigCacheDestinations;

package/compiler/copy-config-cache.d.ts

@@ -1,17 +0,0 @@
-import { SaltyCompiler } from './salty-compiler';
-/**
- * `copyConfigCache` plugin option:
- * - `true`  → copy to the bundler's resolved output dir (default).
- * - `false` → no-op.
- * - `string | string[]` → copy to the default destination PLUS each listed path.
- *
- * Each path can be a directory (the file is written as `saltygen/cache/config-cache.json` inside)
- * or a path ending in `.json` (used verbatim).
- */
-export type CopyConfigCacheOption = boolean | string | string[];
-export declare const resolveCopyConfigCacheDestinations: (option: CopyConfigCacheOption | undefined, defaultOutDir: string | undefined, cwd?: string) => string[];
-/**
- * Copy the compiler's `config-cache.json` to each absolute destination path.
- * Creates parent directories as needed; silently skips destinations equal to the source.
- */
-export declare const copyConfigCacheTo: (compiler: SaltyCompiler, destinations: string[]) => Promise<void>;