@ryanatkn/gro 0.144.1 → 0.146.0

package/dist/gro.config.default.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gro.config.default.d.ts","sourceRoot":"../src/lib/","sources":["gro.config.default.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,iBAAiB,EAAC,MAAM,iBAAiB,CAAC;AAQvD;;;;;;;;GAQG;AACH,QAAA,MAAM,MAAM,EAAE,iBA0Bb,CAAC;AAEF,eAAe,MAAM,CAAC"}
+{"version":3,"file":"gro.config.default.d.ts","sourceRoot":"../src/lib/","sources":["gro.config.default.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,iBAAiB,EAAC,MAAM,iBAAiB,CAAC;AAQvD;;;;;;;;GAQG;AACH,QAAA,MAAM,MAAM,EAAE,iBAwBb,CAAC;AAEF,eAAe,MAAM,CAAC"}

package/dist/gro.config.default.js

@@ -3,7 +3,7 @@ import { has_server, gro_plugin_server } from './gro_plugin_server.js';
 import { gro_plugin_sveltekit_app } from './gro_plugin_sveltekit_app.js';
 import { has_sveltekit_app, has_sveltekit_library } from './sveltekit_helpers.js';
 import { gro_plugin_gen } from './gro_plugin_gen.js';
-import { gro_plugin_moss, has_moss_dep } from './gro_plugin_moss.js';
+import { has_dep, load_package_json } from './package_json.js';
 /**
  * This is the default config that's passed to `gro.config.ts`
  * if it exists in the current project, and if not, this is the final config.
@@ -14,15 +14,16 @@ import { gro_plugin_moss, has_moss_dep } from './gro_plugin_moss.js';
  * - if `src/lib/server/server.ts`, assumes a Node server
  */
 const config = async (cfg) => {
-    const [moss_plugin_result, has_server_result, has_sveltekit_library_result, has_sveltekit_app_result,] = await Promise.all([
-        has_moss_dep(),
+    const package_json = load_package_json(); // TODO gets wastefully loaded by some plugins, maybe put in plugin/task context? how does that interact with `map_package_json`?
+    const [has_moss_dep, has_server_result, has_sveltekit_library_result, has_sveltekit_app_result] = await Promise.all([
+        has_dep('@ryanatkn/moss', package_json),
         has_server(),
-        has_sveltekit_library(),
+        has_sveltekit_library(package_json),
         has_sveltekit_app(),
     ]);
-    cfg.plugins = () => [
+    cfg.plugins = async () => [
         // put things that generate files before SvelteKit so it can see them
-        moss_plugin_result.ok ? gro_plugin_moss() : null,
+        has_moss_dep ? (await import('./gro_plugin_moss.js')).gro_plugin_moss() : null, // lazy load to avoid errors if it's not installed
         gro_plugin_gen(),
         has_server_result.ok ? gro_plugin_server() : null,
         has_sveltekit_library_result.ok ? gro_plugin_sveltekit_library() : null,

package/dist/gro_plugin_moss.d.ts

@@ -1,22 +1,15 @@
-import type { Result } from '@ryanatkn/belt/result.js';
 import type { Plugin } from './plugin.js';
 import type { Args } from './args.js';
 import type { File_Filter } from './path.js';
-import { type Package_Json } from './package_json.js';
-export declare const MOSS_PACKAGE_DEP_NAME = "@ryanatkn/moss";
-export declare const has_moss_dep: (package_json?: Package_Json, dep_name?: string) => Result<object, {
-    message: string;
-}>;
-export declare const generate_classes_css: (classes: Iterable<string>) => string;
 export interface Task_Args extends Args {
     watch?: boolean;
 }
-export interface Options {
+export interface Gro_Plugin_Moss_Options {
     include_classes?: string[] | Set<string> | null;
     outfile?: string;
     filter_file?: File_Filter | null;
     flush_debounce_delay?: number;
     banner?: string;
 }
-export declare const gro_plugin_moss: ({ include_classes, outfile, filter_file, flush_debounce_delay, banner, }?: Options) => Plugin;
+export declare const gro_plugin_moss: ({ include_classes, outfile, filter_file, flush_debounce_delay, banner, }?: Gro_Plugin_Moss_Options) => Plugin;
 //# sourceMappingURL=gro_plugin_moss.d.ts.map

package/dist/gro_plugin_moss.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gro_plugin_moss.d.ts","sourceRoot":"../src/lib/","sources":["gro_plugin_moss.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,0BAA0B,CAAC;AAErD,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,aAAa,CAAC;AACxC,OAAO,KAAK,EAAC,IAAI,EAAC,MAAM,WAAW,CAAC;AAGpC,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,WAAW,CAAC;AAC3C,OAAO,EAAU,KAAK,YAAY,EAAC,MAAM,mBAAmB,CAAC;AAE7D,eAAO,MAAM,qBAAqB,mBAAmB,CAAC;AAEtD,eAAO,MAAM,YAAY,kBACT,YAAY,wBAEzB,MAAM,CAAC,MAAM,EAAE;IAAC,OAAO,EAAE,MAAM,CAAA;CAAC,CASlC,CAAC;AAEF,eAAO,MAAM,oBAAoB,YAAa,QAAQ,CAAC,MAAM,CAAC,KAAG,MAmBhE,CAAC;AAIF,MAAM,WAAW,SAAU,SAAQ,IAAI;IACtC,KAAK,CAAC,EAAE,OAAO,CAAC;CAChB;AAED,MAAM,WAAW,OAAO;IACvB,eAAe,CAAC,EAAE,MAAM,EAAE,GAAG,GAAG,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC;IAChD,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,WAAW,GAAG,IAAI,CAAC;IACjC,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,MAAM,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,eAAO,MAAM,eAAe,8EAMzB,OAAO,KAAkB,MAmE3B,CAAC"}
+{"version":3,"file":"gro_plugin_moss.d.ts","sourceRoot":"../src/lib/","sources":["gro_plugin_moss.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,aAAa,CAAC;AACxC,OAAO,KAAK,EAAC,IAAI,EAAC,MAAM,WAAW,CAAC;AAGpC,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,WAAW,CAAC;AAI3C,MAAM,WAAW,SAAU,SAAQ,IAAI;IACtC,KAAK,CAAC,EAAE,OAAO,CAAC;CAChB;AAED,MAAM,WAAW,uBAAuB;IACvC,eAAe,CAAC,EAAE,MAAM,EAAE,GAAG,GAAG,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC;IAChD,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,WAAW,GAAG,IAAI,CAAC;IACjC,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,MAAM,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,eAAO,MAAM,eAAe,8EAMzB,uBAAuB,KAAkB,MAmE3C,CAAC"}

package/dist/gro_plugin_moss.js

@@ -2,40 +2,9 @@ import { EMPTY_OBJECT } from '@ryanatkn/belt/object.js';
 import { throttle } from '@ryanatkn/belt/throttle.js';
 import { Unreachable_Error } from '@ryanatkn/belt/error.js';
 import { writeFileSync } from 'node:fs';
-import { collect_css_classes, Css_Classes } from '@ryanatkn/moss/css_class_helpers.js';
+import { collect_css_classes, Css_Classes, generate_classes_css, } from '@ryanatkn/moss/css_class_helpers.js';
 import { css_classes_by_name } from '@ryanatkn/moss/css_classes.js';
 import { format_file } from './format_file.js';
-import { has_dep } from './package_json.js';
-export const MOSS_PACKAGE_DEP_NAME = '@ryanatkn/moss';
-export const has_moss_dep = (package_json, dep_name = MOSS_PACKAGE_DEP_NAME) => {
-    if (!has_dep(dep_name, package_json)) {
-        return {
-            ok: false,
-            message: `no dependency found in package.json for ${dep_name}`,
-        };
-    }
-    return { ok: true };
-};
-export const generate_classes_css = (classes) => {
-    let css = '';
-    for (const c of classes) {
-        const v = css_classes_by_name[c];
-        if (!v) {
-            // diagnostic
-            // if (!/^[a-z_0-9]+$/.test(c)) {
-            // 	console.error('invalid class detected, fix the regexps', c);
-            // }
-            continue;
-        }
-        if ('declaration' in v) {
-            css += `.${c} { ${v.declaration} }\n`;
-        }
-        else {
-            css += v.ruleset + '\n';
-        }
-    }
-    return css;
-};
 const FLUSH_DEBOUNCE_DELAY = 500;
 export const gro_plugin_moss = ({ include_classes = null, outfile = 'src/routes/moss.css', // TODO maybe support multiple files using file filters to check where to collect them?
 filter_file = (p) => !p.includes('.test.') && !p.includes('/test/'), flush_debounce_delay = FLUSH_DEBOUNCE_DELAY, banner = 'generated by gro_plugin_moss', } = EMPTY_OBJECT) => {
@@ -51,7 +20,7 @@ filter_file = (p) => !p.includes('.test.') && !p.includes('/test/'), flush_debou
         }
     };
     const flush_gen_queue = throttle(async () => {
-        const css = generate_classes_css(css_classes.get_sorted_array());
+        const css = generate_classes_css(css_classes.get_sorted_array(), css_classes_by_name);
         const contents = `/* ${banner} */\n\n${css}\n\n/* ${banner} */`;
         const output = await format_file(contents, { filepath: outfile });
         // TODO think about using gen to implement this, would have some nice benefits like automatic change detection

package/dist/gro_plugin_sveltekit_library.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gro_plugin_sveltekit_library.d.ts","sourceRoot":"../src/lib/","sources":["gro_plugin_sveltekit_library.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,aAAa,CAAC;AAGxC,OAAO,EAGN,KAAK,sBAAsB,EAC3B,MAAM,wBAAwB,CAAC;AAEhC,MAAM,WAAW,oCAAoC;IACpD;;;OAGG;IACH,sBAAsB,CAAC,EAAE,sBAAsB,CAAC;IAChD;;;OAGG;IACH,kBAAkB,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED,eAAO,MAAM,4BAA4B,qDAGtC,oCAAoC,KAAQ,MA8B9C,CAAC"}
+{"version":3,"file":"gro_plugin_sveltekit_library.d.ts","sourceRoot":"../src/lib/","sources":["gro_plugin_sveltekit_library.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,aAAa,CAAC;AAGxC,OAAO,EAGN,KAAK,sBAAsB,EAC3B,MAAM,wBAAwB,CAAC;AAEhC,MAAM,WAAW,oCAAoC;IACpD;;;OAGG;IACH,sBAAsB,CAAC,EAAE,sBAAsB,CAAC;IAChD;;;OAGG;IACH,kBAAkB,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED,eAAO,MAAM,4BAA4B,qDAGtC,oCAAoC,KAAQ,MAoC9C,CAAC"}

package/dist/gro_plugin_sveltekit_library.js

@@ -3,15 +3,15 @@ import { Task_Error } from './task.js';
 import { load_package_json } from './package_json.js';
 import { SVELTE_PACKAGE_CLI, run_svelte_package, } from './sveltekit_helpers.js';
 export const gro_plugin_sveltekit_library = ({ svelte_package_options, svelte_package_cli = SVELTE_PACKAGE_CLI, } = {}) => {
+    const package_json = load_package_json();
     return {
         name: 'gro_plugin_sveltekit_library',
         setup: async ({ dev, log, config }) => {
             if (!dev) {
-                await run_svelte_package(svelte_package_options, svelte_package_cli, log, config.pm_cli);
+                await run_svelte_package(package_json, svelte_package_options, svelte_package_cli, log, config.pm_cli);
             }
         },
         adapt: async ({ log, timings, config }) => {
-            const package_json = load_package_json();
             // link the CLI binaries if they exist
             if (package_json.bin) {
                 const timing_to_link = timings.start(`${config.pm_cli} link`);

package/dist/loader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"loader.d.ts","sourceRoot":"../src/lib/","sources":["loader.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,QAAQ,EAAE,WAAW,EAAC,MAAM,aAAa,CAAC;AAgFvD,eAAO,MAAM,IAAI,EAAE,QAwFlB,CAAC;AAEF,eAAO,MAAM,OAAO,EAAE,WA4DrB,CAAC"}
+{"version":3,"file":"loader.d.ts","sourceRoot":"../src/lib/","sources":["loader.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,QAAQ,EAAE,WAAW,EAAC,MAAM,aAAa,CAAC;AAgFvD,eAAO,MAAM,IAAI,EAAE,QAwFlB,CAAC;AAEF,eAAO,MAAM,OAAO,EAAE,WA6DrB,CAAC"}

package/dist/loader.js

@@ -148,6 +148,7 @@ export const resolve = async (specifier, context, nextResolve) => {
     }
     // Special case for Gro's dependencies that import into Gro.
     // Without this, we'd need to add a dev dep to Gro for Gro, which causes problems.
+    // TODO maybe make this generic, checking `package_json.name` against `s` and map it, possibly need to export `resolve_exported_value`
     if (IS_THIS_GRO && s.startsWith('@ryanatkn/gro')) {
         s = join(dir, 'dist', s.substring(13));
     }

package/dist/package.d.ts

@@ -285,10 +285,6 @@ export declare const package_json: {
             types: string;
             default: string;
         };
-        './moss_helpers.js': {
-            types: string;
-            default: string;
-        };
         './package_json.js': {
             types: string;
             default: string;
@@ -746,13 +742,10 @@ export declare const src_json: {
             path: string;
             declarations: ({
                 name: string;
-                kind: "variable";
+                kind: "type";
             } | {
                 name: string;
                 kind: "function";
-            } | {
-                name: string;
-                kind: "type";
             })[];
         };
         './gro_plugin_server.js': {
@@ -864,16 +857,6 @@ export declare const src_json: {
                 kind: "function";
             })[];
         };
-        './moss_helpers.js': {
-            path: string;
-            declarations: ({
-                name: string;
-                kind: "variable";
-            } | {
-                name: string;
-                kind: "function";
-            })[];
-        };
         './package_json.js': {
             path: string;
             declarations: ({

package/dist/package.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"package.d.ts","sourceRoot":"../src/lib/","sources":["package.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwQD,CAAC;AAEzB,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqxBD,CAAC"}
+{"version":3,"file":"package.d.ts","sourceRoot":"../src/lib/","sources":["package.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuQD,CAAC;AAEzB,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2wBD,CAAC"}

package/dist/package.js

@@ -1,7 +1,7 @@
 // generated by src/lib/package.gen.ts
 export const package_json = {
     name: '@ryanatkn/gro',
-    version: '0.144.1',
+    version: '0.146.0',
     description: 'task runner and toolkit extending SvelteKit',
     motto: 'generate, run, optimize',
     glyph: '🌰',
@@ -55,22 +55,22 @@ export const package_json = {
     devDependencies: {
         '@changesets/changelog-git': '^0.2.0',
         '@changesets/types': '^6.0.0',
-        '@ryanatkn/eslint-config': '^0.5.5',
+        '@ryanatkn/eslint-config': '^0.5.6',
         '@ryanatkn/fuz': '^0.130.3',
-        '@ryanatkn/moss': '^0.19.0',
+        '@ryanatkn/moss': '^0.20.0',
         '@sveltejs/adapter-static': '^3.0.6',
         '@sveltejs/kit': '^2.7.3',
         '@sveltejs/package': '^2.3.7',
         '@sveltejs/vite-plugin-svelte': '^4.0.0',
         '@types/fs-extra': '^11.0.4',
-        '@types/node': '^22.8.4',
+        '@types/node': '^22.8.5',
         esbuild: '^0.21.5',
         eslint: '^9.13.0',
         'eslint-plugin-svelte': '^2.46.0',
-        svelte: '^5.1.5',
+        svelte: '^5.1.6',
         'svelte-check': '^4.0.5',
         typescript: '^5.6.3',
-        'typescript-eslint': '^8.12.1',
+        'typescript-eslint': '^8.12.2',
         uvu: '^0.5.6',
     },
     prettier: {
@@ -181,7 +181,6 @@ export const package_json = {
         './loader.js': { types: './dist/loader.d.ts', default: './dist/loader.js' },
         './module.js': { types: './dist/module.d.ts', default: './dist/module.js' },
         './modules.js': { types: './dist/modules.d.ts', default: './dist/modules.js' },
-        './moss_helpers.js': { types: './dist/moss_helpers.d.ts', default: './dist/moss_helpers.js' },
         './package_json.js': { types: './dist/package_json.d.ts', default: './dist/package_json.js' },
         './package_meta.js': { types: './dist/package_meta.d.ts', default: './dist/package_meta.js' },
         './package.gen.js': { types: './dist/package.gen.d.ts', default: './dist/package.gen.js' },
@@ -265,7 +264,7 @@ export const package_json = {
 };
 export const src_json = {
     name: '@ryanatkn/gro',
-    version: '0.144.1',
+    version: '0.146.0',
     modules: {
         '.': {
             path: 'index.ts',
@@ -600,11 +599,8 @@ export const src_json = {
         './gro_plugin_moss.js': {
             path: 'gro_plugin_moss.ts',
             declarations: [
-                { name: 'MOSS_PACKAGE_DEP_NAME', kind: 'variable' },
-                { name: 'has_moss_dep', kind: 'function' },
-                { name: 'generate_classes_css', kind: 'function' },
                 { name: 'Task_Args', kind: 'type' },
-                { name: 'Options', kind: 'type' },
+                { name: 'Gro_Plugin_Moss_Options', kind: 'type' },
                 { name: 'gro_plugin_moss', kind: 'function' },
             ],
         },
@@ -697,13 +693,6 @@ export const src_json = {
                 { name: 'load_modules', kind: 'function' },
             ],
         },
-        './moss_helpers.js': {
-            path: 'moss_helpers.ts',
-            declarations: [
-                { name: 'MOSS_PACKAGE_DEP_NAME', kind: 'variable' },
-                { name: 'load_moss_plugin', kind: 'function' },
-            ],
-        },
         './package_json.js': {
             path: 'package_json.ts',
             declarations: [

package/dist/publish.task.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"publish.task.d.ts","sourceRoot":"../src/lib/","sources":["publish.task.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AAItB,OAAO,EAAa,KAAK,IAAI,EAAC,MAAM,WAAW,CAAC;AAgBhD,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyBP,CAAC;AACX,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,IAAI,CAAC,CAAC;AAExC,eAAO,MAAM,IAAI,EAAE,IAAI,CAAC,IAAI,CA0I3B,CAAC"}
+{"version":3,"file":"publish.task.d.ts","sourceRoot":"../src/lib/","sources":["publish.task.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AAItB,OAAO,EAAa,KAAK,IAAI,EAAC,MAAM,WAAW,CAAC;AAgBhD,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyBP,CAAC;AACX,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,IAAI,CAAC,CAAC;AAExC,eAAO,MAAM,IAAI,EAAE,IAAI,CAAC,IAAI,CA2I3B,CAAC"}

package/dist/publish.task.js

@@ -43,7 +43,8 @@ export const task = {
         if (dry) {
             log.info(st('green', 'dry run!'));
         }
-        const has_sveltekit_library_result = has_sveltekit_library();
+        const package_json = load_package_json();
+        const has_sveltekit_library_result = has_sveltekit_library(package_json);
         if (!has_sveltekit_library_result.ok) {
             throw new Task_Error('Failed to find SvelteKit library: ' + has_sveltekit_library_result.message);
         }
@@ -76,11 +77,10 @@ export const task = {
             log.info('dry run, skipping changeset version');
         }
         else {
-            const package_json_before = load_package_json();
-            if (typeof package_json_before.version !== 'string') {
+            if (typeof package_json.version !== 'string') {
                 throw new Task_Error('Failed to find package.json version');
             }
-            const parsed_repo_url = parse_repo_url(package_json_before);
+            const parsed_repo_url = parse_repo_url(package_json);
             if (!parsed_repo_url) {
                 throw new Task_Error('package.json `repository` must contain a repo url (and GitHub only for now, sorry),' +
                     ' like `git+https://github.com/ryanatkn/gro.git` or `https://github.com/ryanatkn/gro`' +
@@ -98,9 +98,9 @@ export const task = {
                 }
                 await update_changelog(parsed_repo_url.owner, parsed_repo_url.repo, changelog, token, log);
             }
-            const package_json_after = load_package_json();
-            version = package_json_after.version;
-            if (package_json_before.version === version) {
+            const package_json_after_versioning = load_package_json();
+            version = package_json_after_versioning.version;
+            if (package_json.version === version) {
                 // The version didn't change.
                 // For now this is the best detection we have for a no-op `changeset version`.
                 if (optional) {

package/dist/release.task.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"release.task.d.ts","sourceRoot":"../src/lib/","sources":["release.task.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AAEtB,OAAO,KAAK,EAAC,IAAI,EAAC,MAAM,WAAW,CAAC;AAGpC,eAAO,MAAM,IAAI,iDAAwB,CAAC;AAC1C,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,IAAI,CAAC,CAAC;AAExC,eAAO,MAAM,IAAI,EAAE,IAAI,CAAC,IAAI,CAY3B,CAAC"}
+{"version":3,"file":"release.task.d.ts","sourceRoot":"../src/lib/","sources":["release.task.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AAEtB,OAAO,KAAK,EAAC,IAAI,EAAC,MAAM,WAAW,CAAC;AAIpC,eAAO,MAAM,IAAI,iDAAwB,CAAC;AAC1C,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,IAAI,CAAC,CAAC;AAExC,eAAO,MAAM,IAAI,EAAE,IAAI,CAAC,IAAI,CAc3B,CAAC"}

package/dist/release.task.js

@@ -1,11 +1,13 @@
 import { z } from 'zod';
 import { has_sveltekit_library, has_sveltekit_app } from './sveltekit_helpers.js';
+import { load_package_json } from './package_json.js';
 export const Args = z.object({}).strict();
 export const task = {
     summary: 'publish and deploy',
     Args,
     run: async ({ invoke_task }) => {
-        const publish = has_sveltekit_library().ok;
+        const package_json = load_package_json();
+        const publish = has_sveltekit_library(package_json).ok;
         if (publish) {
             await invoke_task('publish', { optional: true });
         }

package/dist/resolve_node_specifier.d.ts

@@ -1,7 +1,9 @@
 import { Package_Json } from './package_json.js';
 import type { Resolved_Specifier } from './resolve_specifier.js';
 /**
+ * Ideally Gro would just use `import.meta.resolve`, but it can't be used in custom loaders,
+ * which Gro relies on for TypeScript.
  * This likely has differences from Node - they should be fixed on a case-by-case basis.
  */
-export declare const resolve_node_specifier: (specifier: string, dir?: string, parent_path?: string, cache?: Record<string, Package_Json>, throw_on_missing_package?: boolean, exports_conditions?: string[]) => Resolved_Specifier | null;
+export declare const resolve_node_specifier: (specifier: string, dir?: string, parent_path?: string, package_json_cache?: Record<string, Package_Json>, throw_on_missing_package?: boolean, exports_conditions?: string[]) => Resolved_Specifier | null;
 //# sourceMappingURL=resolve_node_specifier.d.ts.map

package/dist/resolve_node_specifier.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"resolve_node_specifier.d.ts","sourceRoot":"../src/lib/","sources":["resolve_node_specifier.ts"],"names":[],"mappings":"AAIA,OAAO,EAAe,YAAY,EAAoB,MAAM,mBAAmB,CAAC;AAGhF,OAAO,KAAK,EAAC,kBAAkB,EAAC,MAAM,wBAAwB,CAAC;AAG/D;;GAEG;AACH,eAAO,MAAM,sBAAsB,cACvB,MAAM,8BAEH,MAAM,UACZ,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,wEAGlC,kBAAkB,GAAG,IA6FvB,CAAC"}
+{"version":3,"file":"resolve_node_specifier.d.ts","sourceRoot":"../src/lib/","sources":["resolve_node_specifier.ts"],"names":[],"mappings":"AAKA,OAAO,EAAe,YAAY,EAAoB,MAAM,mBAAmB,CAAC;AAGhF,OAAO,KAAK,EAAC,kBAAkB,EAAC,MAAM,wBAAwB,CAAC;AAE/D;;;;GAIG;AACH,eAAO,MAAM,sBAAsB,cACvB,MAAM,8BAEH,MAAM,uBACC,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,wEAG/C,kBAAkB,GAAG,IAsFvB,CAAC"}

package/dist/resolve_node_specifier.js

@@ -1,40 +1,31 @@
 import { join, extname } from 'node:path';
 import { existsSync } from 'node:fs';
 import { DEV } from 'esm-env';
+import { escape_regexp } from '@ryanatkn/belt/regexp.js';
 import { Export_Value, Package_Json, load_package_json } from './package_json.js';
 import { paths } from './paths.js';
 import { NODE_MODULES_DIRNAME } from './constants.js';
-import { escape_regexp } from '@ryanatkn/belt/regexp.js';
 /**
+ * Ideally Gro would just use `import.meta.resolve`, but it can't be used in custom loaders,
+ * which Gro relies on for TypeScript.
  * This likely has differences from Node - they should be fixed on a case-by-case basis.
  */
-export const resolve_node_specifier = (specifier, dir = paths.root, parent_path, cache, throw_on_missing_package = true, exports_conditions = DEV ? ['development', 'node', 'import'] : ['production', 'node', 'import']) => {
+export const resolve_node_specifier = (specifier, dir = paths.root, parent_path, package_json_cache, throw_on_missing_package = true, exports_conditions = DEV ? ['development', 'node', 'import'] : ['production', 'node', 'import']) => {
     const raw = specifier.endsWith('?raw');
     const mapped_specifier = raw ? specifier.substring(0, specifier.length - 4) : specifier;
-    // Parse the specifier
-    let idx = -1;
-    if (mapped_specifier[0] === '@') {
-        let count = 0;
-        for (let i = 0; i < mapped_specifier.length; i++) {
-            if (mapped_specifier[i] === '/')
-                count++;
-            if (count === 2) {
-                idx = i;
-                break;
-            }
-        }
-    }
-    else {
-        idx = mapped_specifier.indexOf('/');
-    }
-    const pkg_name = idx === -1 ? mapped_specifier : mapped_specifier.substring(0, idx);
-    const module_path = idx === -1 ? '' : mapped_specifier.substring(idx + 1);
+    const specifier_slash_path_index = get_specifier_slash_path_index(mapped_specifier);
+    const pkg_name = specifier_slash_path_index === -1
+        ? mapped_specifier
+        : mapped_specifier.substring(0, specifier_slash_path_index);
+    const module_path = specifier_slash_path_index === -1
+        ? ''
+        : mapped_specifier.substring(specifier_slash_path_index + 1);
     const subpath = module_path ? './' + module_path : '.';
     const package_dir = join(dir, NODE_MODULES_DIRNAME, pkg_name);
-    // Check cache first
+    // Check package_json cache first
     let package_json;
-    if (cache?.[pkg_name]) {
-        package_json = cache[pkg_name];
+    if (package_json_cache?.[pkg_name]) {
+        package_json = package_json_cache[pkg_name];
     }
     else if (!existsSync(package_dir)) {
         if (throw_on_missing_package) {
@@ -46,7 +37,7 @@ export const resolve_node_specifier = (specifier, dir = paths.root, parent_path,
         }
     }
     else {
-        package_json = load_package_json(package_dir, cache, false);
+        package_json = load_package_json(package_dir, package_json_cache, false);
     }
     // Handle self-referencing
     if (parent_path?.startsWith(package_dir)) {
@@ -117,6 +108,7 @@ const resolve_subpath = (package_json, subpath) => {
         if (subpath in exports) {
             return exports[subpath];
         }
+        // TODO some of this may be wrong, will just need to patch as we go
         // Sort patterns by specificity
         const patterns = Object.entries(exports)
             .filter(([pattern]) => pattern.includes('*'))
@@ -207,8 +199,7 @@ const resolve_exported_value = (exported, conditions) => {
         return undefined;
     }
     const exported_obj = exported;
-    // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents
-    let default_value;
+    let default_value; // eslint-disable-line @typescript-eslint/no-redundant-type-constituents
     // For each key in exported_obj, in order
     for (const [condition, value] of Object.entries(exported_obj)) {
         // Skip invalid conditions
@@ -295,3 +286,21 @@ const validate_export_target = (target, throw_on_missing_package) => {
         }
     }
 };
+const get_specifier_slash_path_index = (mapped_specifier) => {
+    let index = -1;
+    if (mapped_specifier[0] === '@') {
+        let count = 0;
+        for (let i = 0; i < mapped_specifier.length; i++) {
+            if (mapped_specifier[i] === '/')
+                count++;
+            if (count === 2) {
+                index = i;
+                break;
+            }
+        }
+    }
+    else {
+        index = mapped_specifier.indexOf('/');
+    }
+    return index;
+};

package/dist/sveltekit_helpers.d.ts

@@ -12,7 +12,7 @@ export declare const SVELTEKIT_ENV_MATCHER: RegExp;
 export declare const has_sveltekit_app: () => Result<object, {
     message: string;
 }>;
-export declare const has_sveltekit_library: (package_json?: Package_Json, sveltekit_config?: Parsed_Sveltekit_Config, dep_name?: string) => Result<object, {
+export declare const has_sveltekit_library: (package_json: Package_Json, sveltekit_config?: Parsed_Sveltekit_Config, dep_name?: string) => Result<object, {
     message: string;
 }>;
 export declare const sveltekit_sync: (sveltekit_cli?: string | Cli, pm_cli?: string) => Promise<void>;
@@ -73,7 +73,7 @@ export interface Svelte_Package_Options {
      */
     tsconfig?: string;
 }
-export declare const run_svelte_package: (options: Svelte_Package_Options | undefined, cli: string | Cli, log: Logger, pm_cli: string) => Promise<void>;
+export declare const run_svelte_package: (package_json: Package_Json, options: Svelte_Package_Options | undefined, cli: string | Cli, log: Logger, pm_cli: string) => Promise<void>;
 /**
  * Map an import specifier with the SvelteKit aliases.
  */

package/dist/sveltekit_helpers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sveltekit_helpers.d.ts","sourceRoot":"../src/lib/","sources":["sveltekit_helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,0BAA0B,CAAC;AAErD,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,uBAAuB,CAAC;AAGlD,OAAO,EAAC,YAAY,EAAU,MAAM,mBAAmB,CAAC;AACxD,OAAO,EAA2B,KAAK,uBAAuB,EAAC,MAAM,uBAAuB,CAAC;AAE7F,OAAO,EAAmC,KAAK,GAAG,EAAC,MAAM,UAAU,CAAC;AAIpE,eAAO,MAAM,aAAa,eAAe,CAAC;AAE1C,eAAO,MAAM,gBAAgB,iBAAiB,CAAC;AAE/C,eAAO,MAAM,kBAAkB,mBAAmB,CAAC;AACnD,eAAO,MAAM,uBAAuB,sBAAsB,CAAC;AAE3D,eAAO,MAAM,QAAQ,SAAS,CAAC;AAE/B,eAAO,MAAM,qBAAqB,QAAgD,CAAC;AAEnF,eAAO,MAAM,iBAAiB,QAAO,MAAM,CAAC,MAAM,EAAE;IAAC,OAAO,EAAE,MAAM,CAAA;CAAC,CAMpE,CAAC;AAEF,eAAO,MAAM,qBAAqB,kBAClB,YAAY,qBACT,uBAAuB,wBAEvC,MAAM,CAAC,MAAM,EAAE;IAAC,OAAO,EAAE,MAAM,CAAA;CAAC,CAkBlC,CAAC;AAEF,eAAO,MAAM,cAAc,mBACX,MAAM,GAAG,GAAG,sBAEzB,OAAO,CAAC,IAAI,CASd,CAAC;AAGF;;GAEG;AACH,eAAO,MAAM,2BAA2B,mBACxB,MAAM,GAAG,GAAG,KACzB,OAAO,CAAC,IAAI,CAMd,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,kCAAkC,mBAC/B,MAAM,GAAG,GAAG,KACzB,OAAO,CAAC,IAAI,CAUd,CAAC;AAEF;;;GAGG;AACH,MAAM,WAAW,sBAAsB;IACtC;;OAEG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB;;OAEG;IACH,CAAC,CAAC,EAAE,OAAO,CAAC;IACZ;;;OAGG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;;OAEG;IACH,CAAC,CAAC,EAAE,MAAM,CAAC;IACX;;;;;OAKG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;OAEG;IACH,CAAC,CAAC,EAAE,MAAM,CAAC;IACX;;;;OAIG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB;;OAEG;IACH,CAAC,CAAC,EAAE,OAAO,CAAC;IACZ;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,eAAO,MAAM,kBAAkB,YACrB,sBAAsB,GAAG,SAAS,OACtC,MAAM,GAAG,GAAG,OACZ,MAAM,UACH,MAAM,KACZ,OAAO,CAAC,IAAI,CAmBd,CAAC;AAGF;;GAEG;AACH,eAAO,MAAM,qBAAqB,cACtB,MAAM,WACR,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,KAC9B,MASF,CAAC"}
+{"version":3,"file":"sveltekit_helpers.d.ts","sourceRoot":"../src/lib/","sources":["sveltekit_helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,0BAA0B,CAAC;AAErD,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,uBAAuB,CAAC;AAGlD,OAAO,EAAC,YAAY,EAAU,MAAM,mBAAmB,CAAC;AACxD,OAAO,EAA2B,KAAK,uBAAuB,EAAC,MAAM,uBAAuB,CAAC;AAE7F,OAAO,EAAmC,KAAK,GAAG,EAAC,MAAM,UAAU,CAAC;AAIpE,eAAO,MAAM,aAAa,eAAe,CAAC;AAE1C,eAAO,MAAM,gBAAgB,iBAAiB,CAAC;AAE/C,eAAO,MAAM,kBAAkB,mBAAmB,CAAC;AACnD,eAAO,MAAM,uBAAuB,sBAAsB,CAAC;AAE3D,eAAO,MAAM,QAAQ,SAAS,CAAC;AAE/B,eAAO,MAAM,qBAAqB,QAAgD,CAAC;AAEnF,eAAO,MAAM,iBAAiB,QAAO,MAAM,CAAC,MAAM,EAAE;IAAC,OAAO,EAAE,MAAM,CAAA;CAAC,CAMpE,CAAC;AAEF,eAAO,MAAM,qBAAqB,iBACnB,YAAY,qBACR,uBAAuB,wBAEvC,MAAM,CAAC,MAAM,EAAE;IAAC,OAAO,EAAE,MAAM,CAAA;CAAC,CAkBlC,CAAC;AAEF,eAAO,MAAM,cAAc,mBACX,MAAM,GAAG,GAAG,sBAEzB,OAAO,CAAC,IAAI,CASd,CAAC;AAGF;;GAEG;AACH,eAAO,MAAM,2BAA2B,mBACxB,MAAM,GAAG,GAAG,KACzB,OAAO,CAAC,IAAI,CAMd,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,kCAAkC,mBAC/B,MAAM,GAAG,GAAG,KACzB,OAAO,CAAC,IAAI,CAUd,CAAC;AAEF;;;GAGG;AACH,MAAM,WAAW,sBAAsB;IACtC;;OAEG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB;;OAEG;IACH,CAAC,CAAC,EAAE,OAAO,CAAC;IACZ;;;OAGG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;;OAEG;IACH,CAAC,CAAC,EAAE,MAAM,CAAC;IACX;;;;;OAKG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;OAEG;IACH,CAAC,CAAC,EAAE,MAAM,CAAC;IACX;;;;OAIG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB;;OAEG;IACH,CAAC,CAAC,EAAE,OAAO,CAAC;IACZ;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,eAAO,MAAM,kBAAkB,iBAChB,YAAY,WACjB,sBAAsB,GAAG,SAAS,OACtC,MAAM,GAAG,GAAG,OACZ,MAAM,UACH,MAAM,KACZ,OAAO,CAAC,IAAI,CAmBd,CAAC;AAGF;;GAEG;AACH,eAAO,MAAM,qBAAqB,cACtB,MAAM,WACR,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,KAC9B,MASF,CAAC"}

package/dist/sveltekit_helpers.js

@@ -67,8 +67,8 @@ export const sveltekit_sync_if_obviously_needed = async (sveltekit_cli = SVELTEK
     }
     return sveltekit_sync(found_sveltekit_cli);
 };
-export const run_svelte_package = async (options, cli, log, pm_cli) => {
-    const has_sveltekit_library_result = has_sveltekit_library();
+export const run_svelte_package = async (package_json, options, cli, log, pm_cli) => {
+    const has_sveltekit_library_result = has_sveltekit_library(package_json);
     if (!has_sveltekit_library_result.ok) {
         throw new Task_Error('Failed to find SvelteKit library: ' + has_sveltekit_library_result.message);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ryanatkn/gro",
-  "version": "0.144.1",
+  "version": "0.146.0",
   "description": "task runner and toolkit extending SvelteKit",
   "motto": "generate, run, optimize",
   "glyph": "🌰",
@@ -68,22 +68,22 @@
   "devDependencies": {
     "@changesets/changelog-git": "^0.2.0",
     "@changesets/types": "^6.0.0",
-    "@ryanatkn/eslint-config": "^0.5.5",
+    "@ryanatkn/eslint-config": "^0.5.6",
     "@ryanatkn/fuz": "^0.130.3",
-    "@ryanatkn/moss": "^0.19.0",
+    "@ryanatkn/moss": "^0.20.0",
     "@sveltejs/adapter-static": "^3.0.6",
     "@sveltejs/kit": "^2.7.3",
     "@sveltejs/package": "^2.3.7",
     "@sveltejs/vite-plugin-svelte": "^4.0.0",
     "@types/fs-extra": "^11.0.4",
-    "@types/node": "^22.8.4",
+    "@types/node": "^22.8.5",
     "esbuild": "^0.21.5",
     "eslint": "^9.13.0",
     "eslint-plugin-svelte": "^2.46.0",
-    "svelte": "^5.1.5",
+    "svelte": "^5.1.6",
     "svelte-check": "^4.0.5",
     "typescript": "^5.6.3",
-    "typescript-eslint": "^8.12.1",
+    "typescript-eslint": "^8.12.2",
     "uvu": "^0.5.6"
   },
   "prettier": {
@@ -306,10 +306,6 @@
       "types": "./dist/modules.d.ts",
       "default": "./dist/modules.js"
     },
-    "./moss_helpers.js": {
-      "types": "./dist/moss_helpers.d.ts",
-      "default": "./dist/moss_helpers.js"
-    },
     "./package_json.js": {
       "types": "./dist/package_json.d.ts",
       "default": "./dist/package_json.js"

package/src/lib/gro.config.default.ts

@@ -4,7 +4,7 @@ import {has_server, gro_plugin_server} from './gro_plugin_server.js';
 import {gro_plugin_sveltekit_app} from './gro_plugin_sveltekit_app.js';
 import {has_sveltekit_app, has_sveltekit_library} from './sveltekit_helpers.js';
 import {gro_plugin_gen} from './gro_plugin_gen.js';
-import {gro_plugin_moss, has_moss_dep} from './gro_plugin_moss.js';
+import {has_dep, load_package_json} from './package_json.js';
 
 /**
  * This is the default config that's passed to `gro.config.ts`
@@ -16,22 +16,20 @@ import {gro_plugin_moss, has_moss_dep} from './gro_plugin_moss.js';
  * - if `src/lib/server/server.ts`, assumes a Node server
  */
 const config: Create_Gro_Config = async (cfg) => {
-	const [
-		moss_plugin_result,
-		has_server_result,
-		has_sveltekit_library_result,
-		has_sveltekit_app_result,
-	] = await Promise.all([
-		has_moss_dep(),
-		has_server(),
-		has_sveltekit_library(),
-		has_sveltekit_app(),
-	]);
+	const package_json = load_package_json(); // TODO gets wastefully loaded by some plugins, maybe put in plugin/task context? how does that interact with `map_package_json`?
 
-	cfg.plugins = () =>
+	const [has_moss_dep, has_server_result, has_sveltekit_library_result, has_sveltekit_app_result] =
+		await Promise.all([
+			has_dep('@ryanatkn/moss', package_json),
+			has_server(),
+			has_sveltekit_library(package_json),
+			has_sveltekit_app(),
+		]);
+
+	cfg.plugins = async () =>
 		[
 			// put things that generate files before SvelteKit so it can see them
-			moss_plugin_result.ok ? gro_plugin_moss() : null,
+			has_moss_dep ? (await import('./gro_plugin_moss.js')).gro_plugin_moss() : null, // lazy load to avoid errors if it's not installed
 			gro_plugin_gen(),
 			has_server_result.ok ? gro_plugin_server() : null,
 			has_sveltekit_library_result.ok ? gro_plugin_sveltekit_library() : null,

package/src/lib/gro_plugin_moss.ts

@@ -2,53 +2,18 @@ import {EMPTY_OBJECT} from '@ryanatkn/belt/object.js';
 import {throttle} from '@ryanatkn/belt/throttle.js';
 import {Unreachable_Error} from '@ryanatkn/belt/error.js';
 import {writeFileSync} from 'node:fs';
-import {collect_css_classes, Css_Classes} from '@ryanatkn/moss/css_class_helpers.js';
+import {
+	collect_css_classes,
+	Css_Classes,
+	generate_classes_css,
+} from '@ryanatkn/moss/css_class_helpers.js';
 import {css_classes_by_name} from '@ryanatkn/moss/css_classes.js';
-import type {Result} from '@ryanatkn/belt/result.js';
 
 import type {Plugin} from './plugin.js';
 import type {Args} from './args.js';
 import type {Cleanup_Watch} from './filer.js';
 import {format_file} from './format_file.js';
 import type {File_Filter} from './path.js';
-import {has_dep, type Package_Json} from './package_json.js';
-
-export const MOSS_PACKAGE_DEP_NAME = '@ryanatkn/moss';
-
-export const has_moss_dep = (
-	package_json?: Package_Json,
-	dep_name = MOSS_PACKAGE_DEP_NAME,
-): Result<object, {message: string}> => {
-	if (!has_dep(dep_name, package_json)) {
-		return {
-			ok: false,
-			message: `no dependency found in package.json for ${dep_name}`,
-		};
-	}
-
-	return {ok: true};
-};
-
-export const generate_classes_css = (classes: Iterable<string>): string => {
-	let css = '';
-	for (const c of classes) {
-		const v = css_classes_by_name[c];
-		if (!v) {
-			// diagnostic
-			// if (!/^[a-z_0-9]+$/.test(c)) {
-			// 	console.error('invalid class detected, fix the regexps', c);
-			// }
-			continue;
-		}
-		if ('declaration' in v) {
-			css += `.${c} { ${v.declaration} }\n`;
-		} else {
-			css += v.ruleset + '\n';
-		}
-	}
-
-	return css;
-};
 
 const FLUSH_DEBOUNCE_DELAY = 500;
 
@@ -56,7 +21,7 @@ export interface Task_Args extends Args {
 	watch?: boolean;
 }
 
-export interface Options {
+export interface Gro_Plugin_Moss_Options {
 	include_classes?: string[] | Set<string> | null;
 	outfile?: string;
 	filter_file?: File_Filter | null;
@@ -70,7 +35,7 @@ export const gro_plugin_moss = ({
 	filter_file = (p) => !p.includes('.test.') && !p.includes('/test/'),
 	flush_debounce_delay = FLUSH_DEBOUNCE_DELAY,
 	banner = 'generated by gro_plugin_moss',
-}: Options = EMPTY_OBJECT): Plugin => {
+}: Gro_Plugin_Moss_Options = EMPTY_OBJECT): Plugin => {
 	const css_classes = new Css_Classes(
 		Array.isArray(include_classes) ? new Set(include_classes) : include_classes,
 	);
@@ -88,7 +53,7 @@ export const gro_plugin_moss = ({
 	};
 	const flush_gen_queue = throttle(
 		async () => {
-			const css = generate_classes_css(css_classes.get_sorted_array());
+			const css = generate_classes_css(css_classes.get_sorted_array(), css_classes_by_name);
 			const contents = `/* ${banner} */\n\n${css}\n\n/* ${banner} */`;
 			const output = await format_file(contents, {filepath: outfile});
 			// TODO think about using gen to implement this, would have some nice benefits like automatic change detection

package/src/lib/gro_plugin_sveltekit_library.ts

@@ -26,16 +26,22 @@ export const gro_plugin_sveltekit_library = ({
 	svelte_package_options,
 	svelte_package_cli = SVELTE_PACKAGE_CLI,
 }: Gro_Plugin_Sveltekit_Library_Options = {}): Plugin => {
+	const package_json = load_package_json();
+
 	return {
 		name: 'gro_plugin_sveltekit_library',
 		setup: async ({dev, log, config}) => {
 			if (!dev) {
-				await run_svelte_package(svelte_package_options, svelte_package_cli, log, config.pm_cli);
+				await run_svelte_package(
+					package_json,
+					svelte_package_options,
+					svelte_package_cli,
+					log,
+					config.pm_cli,
+				);
 			}
 		},
 		adapt: async ({log, timings, config}) => {
-			const package_json = load_package_json();
-
 			// link the CLI binaries if they exist
 			if (package_json.bin) {
 				const timing_to_link = timings.start(`${config.pm_cli} link`);

package/src/lib/loader.ts

@@ -193,6 +193,7 @@ export const resolve: ResolveHook = async (specifier, context, nextResolve) => {
 
 	// Special case for Gro's dependencies that import into Gro.
 	// Without this, we'd need to add a dev dep to Gro for Gro, which causes problems.
+	// TODO maybe make this generic, checking `package_json.name` against `s` and map it, possibly need to export `resolve_exported_value`
 	if (IS_THIS_GRO && s.startsWith('@ryanatkn/gro')) {
 		s = join(dir, 'dist', s.substring(13));
 	}

package/src/lib/package.ts

@@ -5,7 +5,7 @@ import type {Src_Json} from './src_json.js';
 
 export const package_json = {
 	name: '@ryanatkn/gro',
-	version: '0.144.1',
+	version: '0.146.0',
 	description: 'task runner and toolkit extending SvelteKit',
 	motto: 'generate, run, optimize',
 	glyph: '🌰',
@@ -60,22 +60,22 @@ export const package_json = {
 	devDependencies: {
 		'@changesets/changelog-git': '^0.2.0',
 		'@changesets/types': '^6.0.0',
-		'@ryanatkn/eslint-config': '^0.5.5',
+		'@ryanatkn/eslint-config': '^0.5.6',
 		'@ryanatkn/fuz': '^0.130.3',
-		'@ryanatkn/moss': '^0.19.0',
+		'@ryanatkn/moss': '^0.20.0',
 		'@sveltejs/adapter-static': '^3.0.6',
 		'@sveltejs/kit': '^2.7.3',
 		'@sveltejs/package': '^2.3.7',
 		'@sveltejs/vite-plugin-svelte': '^4.0.0',
 		'@types/fs-extra': '^11.0.4',
-		'@types/node': '^22.8.4',
+		'@types/node': '^22.8.5',
 		esbuild: '^0.21.5',
 		eslint: '^9.13.0',
 		'eslint-plugin-svelte': '^2.46.0',
-		svelte: '^5.1.5',
+		svelte: '^5.1.6',
 		'svelte-check': '^4.0.5',
 		typescript: '^5.6.3',
-		'typescript-eslint': '^8.12.1',
+		'typescript-eslint': '^8.12.2',
 		uvu: '^0.5.6',
 	},
 	prettier: {
@@ -186,7 +186,6 @@ export const package_json = {
 		'./loader.js': {types: './dist/loader.d.ts', default: './dist/loader.js'},
 		'./module.js': {types: './dist/module.d.ts', default: './dist/module.js'},
 		'./modules.js': {types: './dist/modules.d.ts', default: './dist/modules.js'},
-		'./moss_helpers.js': {types: './dist/moss_helpers.d.ts', default: './dist/moss_helpers.js'},
 		'./package_json.js': {types: './dist/package_json.d.ts', default: './dist/package_json.js'},
 		'./package_meta.js': {types: './dist/package_meta.d.ts', default: './dist/package_meta.js'},
 		'./package.gen.js': {types: './dist/package.gen.d.ts', default: './dist/package.gen.js'},
@@ -271,7 +270,7 @@ export const package_json = {
 
 export const src_json = {
 	name: '@ryanatkn/gro',
-	version: '0.144.1',
+	version: '0.146.0',
 	modules: {
 		'.': {
 			path: 'index.ts',
@@ -606,11 +605,8 @@ export const src_json = {
 		'./gro_plugin_moss.js': {
 			path: 'gro_plugin_moss.ts',
 			declarations: [
-				{name: 'MOSS_PACKAGE_DEP_NAME', kind: 'variable'},
-				{name: 'has_moss_dep', kind: 'function'},
-				{name: 'generate_classes_css', kind: 'function'},
 				{name: 'Task_Args', kind: 'type'},
-				{name: 'Options', kind: 'type'},
+				{name: 'Gro_Plugin_Moss_Options', kind: 'type'},
 				{name: 'gro_plugin_moss', kind: 'function'},
 			],
 		},
@@ -703,13 +699,6 @@ export const src_json = {
 				{name: 'load_modules', kind: 'function'},
 			],
 		},
-		'./moss_helpers.js': {
-			path: 'moss_helpers.ts',
-			declarations: [
-				{name: 'MOSS_PACKAGE_DEP_NAME', kind: 'variable'},
-				{name: 'load_moss_plugin', kind: 'function'},
-			],
-		},
 		'./package_json.js': {
 			path: 'package_json.ts',
 			declarations: [

package/src/lib/publish.task.ts

@@ -67,7 +67,9 @@ export const task: Task<Args> = {
 			log.info(st('green', 'dry run!'));
 		}
 
-		const has_sveltekit_library_result = has_sveltekit_library();
+		const package_json = load_package_json();
+
+		const has_sveltekit_library_result = has_sveltekit_library(package_json);
 		if (!has_sveltekit_library_result.ok) {
 			throw new Task_Error(
 				'Failed to find SvelteKit library: ' + has_sveltekit_library_result.message,
@@ -109,11 +111,10 @@ export const task: Task<Args> = {
 		if (dry) {
 			log.info('dry run, skipping changeset version');
 		} else {
-			const package_json_before = load_package_json();
-			if (typeof package_json_before.version !== 'string') {
+			if (typeof package_json.version !== 'string') {
 				throw new Task_Error('Failed to find package.json version');
 			}
-			const parsed_repo_url = parse_repo_url(package_json_before);
+			const parsed_repo_url = parse_repo_url(package_json);
 			if (!parsed_repo_url) {
 				throw new Task_Error(
 					'package.json `repository` must contain a repo url (and GitHub only for now, sorry),' +
@@ -139,9 +140,9 @@ export const task: Task<Args> = {
 				await update_changelog(parsed_repo_url.owner, parsed_repo_url.repo, changelog, token, log);
 			}
 
-			const package_json_after = load_package_json();
-			version = package_json_after.version!;
-			if (package_json_before.version === version) {
+			const package_json_after_versioning = load_package_json();
+			version = package_json_after_versioning.version!;
+			if (package_json.version === version) {
 				// The version didn't change.
 				// For now this is the best detection we have for a no-op `changeset version`.
 				if (optional) {

package/src/lib/release.task.ts

@@ -2,6 +2,7 @@ import {z} from 'zod';
 
 import type {Task} from './task.js';
 import {has_sveltekit_library, has_sveltekit_app} from './sveltekit_helpers.js';
+import {load_package_json} from './package_json.js';
 
 export const Args = z.object({}).strict();
 export type Args = z.infer<typeof Args>;
@@ -10,7 +11,9 @@ export const task: Task<Args> = {
 	summary: 'publish and deploy',
 	Args,
 	run: async ({invoke_task}) => {
-		const publish = has_sveltekit_library().ok;
+		const package_json = load_package_json();
+
+		const publish = has_sveltekit_library(package_json).ok;
 		if (publish) {
 			await invoke_task('publish', {optional: true});
 		}

package/src/lib/resolve_node_specifier.ts

@@ -1,51 +1,46 @@
 import {join, extname} from 'node:path';
 import {existsSync} from 'node:fs';
 import {DEV} from 'esm-env';
+import {escape_regexp} from '@ryanatkn/belt/regexp.js';
 
 import {Export_Value, Package_Json, load_package_json} from './package_json.js';
 import {paths} from './paths.js';
 import {NODE_MODULES_DIRNAME} from './constants.js';
 import type {Resolved_Specifier} from './resolve_specifier.js';
-import {escape_regexp} from '@ryanatkn/belt/regexp.js';
 
 /**
+ * Ideally Gro would just use `import.meta.resolve`, but it can't be used in custom loaders,
+ * which Gro relies on for TypeScript.
  * This likely has differences from Node - they should be fixed on a case-by-case basis.
  */
 export const resolve_node_specifier = (
 	specifier: string,
 	dir = paths.root,
 	parent_path?: string,
-	cache?: Record<string, Package_Json>,
+	package_json_cache?: Record<string, Package_Json>,
 	throw_on_missing_package = true,
 	exports_conditions = DEV ? ['development', 'node', 'import'] : ['production', 'node', 'import'],
 ): Resolved_Specifier | null => {
 	const raw = specifier.endsWith('?raw');
 	const mapped_specifier = raw ? specifier.substring(0, specifier.length - 4) : specifier;
 
-	// Parse the specifier
-	let idx: number = -1;
-	if (mapped_specifier[0] === '@') {
-		let count = 0;
-		for (let i = 0; i < mapped_specifier.length; i++) {
-			if (mapped_specifier[i] === '/') count++;
-			if (count === 2) {
-				idx = i;
-				break;
-			}
-		}
-	} else {
-		idx = mapped_specifier.indexOf('/');
-	}
+	const specifier_slash_path_index = get_specifier_slash_path_index(mapped_specifier);
 
-	const pkg_name = idx === -1 ? mapped_specifier : mapped_specifier.substring(0, idx);
-	const module_path = idx === -1 ? '' : mapped_specifier.substring(idx + 1);
+	const pkg_name =
+		specifier_slash_path_index === -1
+			? mapped_specifier
+			: mapped_specifier.substring(0, specifier_slash_path_index);
+	const module_path =
+		specifier_slash_path_index === -1
+			? ''
+			: mapped_specifier.substring(specifier_slash_path_index + 1);
 	const subpath = module_path ? './' + module_path : '.';
 	const package_dir = join(dir, NODE_MODULES_DIRNAME, pkg_name);
 
-	// Check cache first
+	// Check package_json cache first
 	let package_json: Package_Json | undefined;
-	if (cache?.[pkg_name]) {
-		package_json = cache[pkg_name];
+	if (package_json_cache?.[pkg_name]) {
+		package_json = package_json_cache[pkg_name];
 	} else if (!existsSync(package_dir)) {
 		if (throw_on_missing_package) {
 			throw Error(
@@ -56,7 +51,7 @@ export const resolve_node_specifier = (
 			return null;
 		}
 	} else {
-		package_json = load_package_json(package_dir, cache, false);
+		package_json = load_package_json(package_dir, package_json_cache, false);
 	}
 
 	// Handle self-referencing
@@ -144,6 +139,7 @@ const resolve_subpath = (package_json: Package_Json, subpath: string): unknown =
 			return exports[subpath];
 		}
 
+		// TODO some of this may be wrong, will just need to patch as we go
 		// Sort patterns by specificity
 		const patterns = Object.entries(exports)
 			.filter(([pattern]) => pattern.includes('*'))
@@ -255,8 +251,7 @@ const resolve_exported_value = (
 
 	const exported_obj = exported as Record<string, unknown>;
 
-	// eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents
-	let default_value: Export_Value | undefined;
+	let default_value: Export_Value | undefined; // eslint-disable-line @typescript-eslint/no-redundant-type-constituents
 
 	// For each key in exported_obj, in order
 	for (const [condition, value] of Object.entries(exported_obj)) {
@@ -354,3 +349,21 @@ const validate_export_target = (target: string, throw_on_missing_package: boolea
 		}
 	}
 };
+
+const get_specifier_slash_path_index = (mapped_specifier: string): number => {
+	let index: number = -1;
+	if (mapped_specifier[0] === '@') {
+		let count = 0;
+		for (let i = 0; i < mapped_specifier.length; i++) {
+			if (mapped_specifier[i] === '/') count++;
+			if (count === 2) {
+				index = i;
+				break;
+			}
+		}
+	} else {
+		index = mapped_specifier.indexOf('/');
+	}
+
+	return index;
+};

package/src/lib/sveltekit_helpers.ts

@@ -30,7 +30,7 @@ export const has_sveltekit_app = (): Result<object, {message: string}> => {
 };
 
 export const has_sveltekit_library = (
-	package_json?: Package_Json,
+	package_json: Package_Json,
 	sveltekit_config: Parsed_Sveltekit_Config = default_sveltekit_config,
 	dep_name = SVELTE_PACKAGE_DEP_NAME,
 ): Result<object, {message: string}> => {
@@ -149,12 +149,13 @@ export interface Svelte_Package_Options {
 }
 
 export const run_svelte_package = async (
+	package_json: Package_Json,
 	options: Svelte_Package_Options | undefined,
 	cli: string | Cli,
 	log: Logger,
 	pm_cli: string,
 ): Promise<void> => {
-	const has_sveltekit_library_result = has_sveltekit_library();
+	const has_sveltekit_library_result = has_sveltekit_library(package_json);
 	if (!has_sveltekit_library_result.ok) {
 		throw new Task_Error(
 			'Failed to find SvelteKit library: ' + has_sveltekit_library_result.message,

package/dist/moss_helpers.d.ts

@@ -1,9 +0,0 @@
-import type { Result } from '@ryanatkn/belt/result.js';
-import { type Package_Json } from './package_json.js';
-export declare const MOSS_PACKAGE_DEP_NAME = "@ryanatkn/moss";
-export declare const load_moss_plugin: (package_json?: Package_Json, dep_name?: string, plugin_path?: string, local_plugin_path?: string) => Promise<Result<{
-    gro_plugin_moss: any;
-}, {
-    message: string;
-}>>;
-//# sourceMappingURL=moss_helpers.d.ts.map

package/dist/moss_helpers.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"moss_helpers.d.ts","sourceRoot":"../src/lib/","sources":["moss_helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,0BAA0B,CAAC;AAIrD,OAAO,EAAU,KAAK,YAAY,EAAC,MAAM,mBAAmB,CAAC;AAG7D,eAAO,MAAM,qBAAqB,mBAAmB,CAAC;AAGtD,eAAO,MAAM,gBAAgB,kBACb,YAAY,0EAIzB,OAAO,CAAC,MAAM,CAAC;IAAC,eAAe,EAAE,GAAG,CAAA;CAAC,EAAE;IAAC,OAAO,EAAE,MAAM,CAAA;CAAC,CAAC,CA4B3D,CAAC"}

package/dist/moss_helpers.js

@@ -1,32 +0,0 @@
-import { existsSync } from 'node:fs';
-import { resolve } from 'node:path';
-import { has_dep } from './package_json.js';
-import { NODE_MODULES_DIRNAME } from './constants.js';
-export const MOSS_PACKAGE_DEP_NAME = '@ryanatkn/moss';
-// TODO plugin type?
-export const load_moss_plugin = async (package_json, dep_name = MOSS_PACKAGE_DEP_NAME, plugin_path = `${NODE_MODULES_DIRNAME}/${dep_name}/dist/gro_plugin_moss.js`, // TODO maybe lookup from its `package_json.exports`? kinda unnecessary
-local_plugin_path = 'src/lib/gro_plugin_moss.ts') => {
-    if (!has_dep(dep_name, package_json)) {
-        return {
-            ok: false,
-            message: `no dependency found in package.json for ${dep_name}`,
-        };
-    }
-    let path = undefined;
-    const resolved_local_plugin_path = resolve(local_plugin_path);
-    if (existsSync(resolved_local_plugin_path)) {
-        path = resolved_local_plugin_path;
-    }
-    if (path === undefined) {
-        path = resolve(plugin_path);
-        if (!existsSync(path)) {
-            return {
-                ok: false,
-                // TODO warn?
-                message: `dependency on ${dep_name} detected but plugin not found at ${path}`,
-            };
-        }
-    }
-    const mod = await import(path);
-    return { ok: true, gro_plugin_moss: mod.gro_plugin_moss };
-};

package/src/lib/moss_helpers.ts

@@ -1,44 +0,0 @@
-import type {Result} from '@ryanatkn/belt/result.js';
-import {existsSync} from 'node:fs';
-import {resolve} from 'node:path';
-
-import {has_dep, type Package_Json} from './package_json.js';
-import {NODE_MODULES_DIRNAME} from './constants.js';
-
-export const MOSS_PACKAGE_DEP_NAME = '@ryanatkn/moss';
-
-// TODO plugin type?
-export const load_moss_plugin = async (
-	package_json?: Package_Json,
-	dep_name = MOSS_PACKAGE_DEP_NAME,
-	plugin_path = `${NODE_MODULES_DIRNAME}/${dep_name}/dist/gro_plugin_moss.js`, // TODO maybe lookup from its `package_json.exports`? kinda unnecessary
-	local_plugin_path = 'src/lib/gro_plugin_moss.ts',
-): Promise<Result<{gro_plugin_moss: any}, {message: string}>> => {
-	if (!has_dep(dep_name, package_json)) {
-		return {
-			ok: false,
-			message: `no dependency found in package.json for ${dep_name}`,
-		};
-	}
-
-	let path: string | undefined = undefined;
-
-	const resolved_local_plugin_path = resolve(local_plugin_path);
-	if (existsSync(resolved_local_plugin_path)) {
-		path = resolved_local_plugin_path;
-	}
-
-	if (path === undefined) {
-		path = resolve(plugin_path);
-		if (!existsSync(path)) {
-			return {
-				ok: false,
-				// TODO warn?
-				message: `dependency on ${dep_name} detected but plugin not found at ${path}`,
-			};
-		}
-	}
-
-	const mod = await import(path);
-	return {ok: true, gro_plugin_moss: mod.gro_plugin_moss};
-};