@ryanatkn/gro 0.129.0 → 0.129.2

package/dist/plugin.test.js

@@ -1,7 +1,7 @@
 import { test } from 'uvu';
 import * as assert from 'uvu/assert';
 import { replace_plugin } from './plugin.js';
-test('replace_plugin', async () => {
+test('replace_plugin', () => {
     const a = { name: 'a' };
     const b = { name: 'b' };
     const c = { name: 'c' };
@@ -32,13 +32,13 @@ test('replace_plugin', async () => {
     assert.is(p[1], b2);
     assert.is(p[2], c2);
 });
-test('replace_plugin without an array', async () => {
+test('replace_plugin without an array', () => {
     const a = { name: 'a' };
     const a2 = { name: 'a' };
     const p = replace_plugin(a, a2);
     assert.is(p[0], a2);
 });
-test('replace_plugin throws if it cannot find the given name', async () => {
+test('replace_plugin throws if it cannot find the given name', () => {
     const a = { name: 'a' };
     const plugins = [a];
     let err;

package/dist/publish.task.js

@@ -52,7 +52,7 @@ export const task = {
         if (dry) {
             log.info(green('dry run!'));
         }
-        const has_sveltekit_library_result = await has_sveltekit_library();
+        const has_sveltekit_library_result = has_sveltekit_library();
         if (!has_sveltekit_library_result.ok) {
             throw new Task_Error('Failed to find SvelteKit library: ' + has_sveltekit_library_result.message);
         }
@@ -88,7 +88,7 @@ export const task = {
             log.info('dry run, skipping changeset version');
         }
         else {
-            const package_json_before = await load_package_json();
+            const package_json_before = load_package_json();
             if (typeof package_json_before.version !== 'string') {
                 throw new Task_Error('Failed to find package.json version');
             }
@@ -104,13 +104,13 @@ export const task = {
                 throw Error('npm version failed: no commits were made: see the error above');
             }
             if (!preserve_changelog) {
-                const token = await load_from_env('GITHUB_TOKEN_SECRET');
+                const token = load_from_env('GITHUB_TOKEN_SECRET');
                 if (!token) {
                     log.warn('the env var GITHUB_TOKEN_SECRET was not found, so API calls with be unauthorized');
                 }
                 await update_changelog(parsed_repo_url.owner, parsed_repo_url.repo, changelog, token, log);
             }
-            const package_json_after = await load_package_json();
+            const package_json_after = load_package_json();
             version = package_json_after.version;
             if (package_json_before.version === version) {
                 // The version didn't change.

package/dist/release.task.js

@@ -5,11 +5,11 @@ export const task = {
     summary: 'publish and deploy',
     Args,
     run: async ({ invoke_task }) => {
-        const publish = (await has_sveltekit_library()).ok;
+        const publish = has_sveltekit_library().ok;
         if (publish) {
             await invoke_task('publish', { optional: true });
         }
-        if ((await has_sveltekit_app()).ok) {
+        if (has_sveltekit_app().ok) {
             await invoke_task('deploy', { build: !publish });
         }
     },

package/dist/resolve.task.d.ts

@@ -2,10 +2,13 @@ import { z } from 'zod';
 import { type Task } from './task.js';
 export declare const Args: z.ZodObject<{
     _: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    verbose: z.ZodDefault<z.ZodBoolean>;
 }, "strict", z.ZodTypeAny, {
     _: string[];
+    verbose: boolean;
 }, {
     _?: string[] | undefined;
+    verbose?: boolean | undefined;
 }>;
 export type Args = z.infer<typeof Args>;
 export declare const task: Task<Args>;

package/dist/resolve.task.js

@@ -1,24 +1,38 @@
 import { z } from 'zod';
+import { green, yellow } from '@ryanatkn/belt/styletext.js';
 import { TASK_FILE_SUFFIXES } from './task.js';
 import { resolve_input_paths, to_input_paths } from './input_path.js';
 export const Args = z
     .object({
     _: z.array(z.string(), { description: 'the input paths to resolve' }).default(['']),
+    verbose: z.boolean({ description: 'log diagnostics' }).default(false),
 })
     .strict();
 export const task = {
     summary: 'diagnostic that logs resolved filesystem info for the given input paths',
     Args,
-    run: async ({ args, config, log }) => {
-        const { _ } = args;
-        log.info('raw input paths:', _);
+    run: ({ args, config, log }) => {
+        const { _, verbose } = args;
+        if (verbose)
+            log.info('raw input paths:', _);
         const input_paths = to_input_paths(_);
-        log.info('input paths:', input_paths);
+        if (verbose)
+            log.info('input paths:', input_paths);
         const { task_root_dirs } = config;
-        log.info('task root paths:', task_root_dirs);
+        if (verbose)
+            log.info('task root paths:', task_root_dirs);
         const { resolved_input_paths, possible_paths_by_input_path, unmapped_input_paths } = resolve_input_paths(input_paths, task_root_dirs, TASK_FILE_SUFFIXES);
-        log.info('resolved_input_paths:', resolved_input_paths);
-        log.info('possible_paths_by_input_path:', possible_paths_by_input_path);
-        log.info('unmapped_input_paths:', unmapped_input_paths);
+        if (verbose)
+            log.info('resolved_input_paths:', resolved_input_paths);
+        if (verbose)
+            log.info('possible_paths_by_input_path:', possible_paths_by_input_path);
+        if (verbose)
+            log.info('unmapped_input_paths:', unmapped_input_paths);
+        for (const p of resolved_input_paths) {
+            log.info('resolved:', green(p.id));
+        }
+        if (!resolved_input_paths.length) {
+            log.warn(yellow('no input paths were resolved'));
+        }
     },
 };

package/dist/resolve_node_specifier.d.ts

@@ -1,6 +1,6 @@
 import { Package_Json } from './package_json.js';
 import type { Path_Id } from './path.js';
-export declare const resolve_node_specifier: (specifier: string, dir?: string, parent_url?: string, cache?: Record<string, Package_Json>, exports_key?: string) => Promise<Path_Id>;
+export declare const resolve_node_specifier: (specifier: string, dir?: string, parent_url?: string, cache?: Record<string, Package_Json>, exports_key?: string) => Path_Id;
 export interface Parsed_Node_Specifier {
     name: string;
     path: string;

package/dist/resolve_node_specifier.js

@@ -2,11 +2,11 @@ import { join } from 'node:path';
 import { Package_Json, load_package_json } from './package_json.js';
 import { paths } from './paths.js';
 import { NODE_MODULES_DIRNAME } from './path_constants.js';
-export const resolve_node_specifier = async (specifier, dir = paths.root, parent_url, cache, exports_key = specifier.endsWith('.svelte') ? 'svelte' : 'default') => {
+export const resolve_node_specifier = (specifier, dir = paths.root, parent_url, cache, exports_key = specifier.endsWith('.svelte') ? 'svelte' : 'default') => {
     const parsed = parse_node_specifier(specifier);
     const subpath = './' + parsed.path;
     const package_dir = join(dir, NODE_MODULES_DIRNAME, parsed.name);
-    const package_json = await load_package_json(package_dir, cache);
+    const package_json = load_package_json(package_dir, cache);
     const exported = package_json.exports?.[subpath];
     if (!exported) {
         // same error message as Node

package/dist/resolve_node_specifier.test.js

@@ -2,16 +2,16 @@ import { test } from 'uvu';
 import * as assert from 'uvu/assert';
 import { resolve_node_specifier } from './resolve_node_specifier.js';
 import { paths } from './paths.js';
-test('resolves a JS specifier', async () => {
-    assert.is(await resolve_node_specifier('@ryanatkn/fuz/tome.js'), paths.root + 'node_modules/@ryanatkn/fuz/dist/tome.js');
+test('resolves a JS specifier', () => {
+    assert.is(resolve_node_specifier('@ryanatkn/fuz/tome.js'), paths.root + 'node_modules/@ryanatkn/fuz/dist/tome.js');
 });
-test('resolves a Svelte specifier', async () => {
-    assert.is(await resolve_node_specifier('@ryanatkn/fuz/Library.svelte'), paths.root + 'node_modules/@ryanatkn/fuz/dist/Library.svelte');
+test('resolves a Svelte specifier', () => {
+    assert.is(resolve_node_specifier('@ryanatkn/fuz/Library.svelte'), paths.root + 'node_modules/@ryanatkn/fuz/dist/Library.svelte');
 });
-test('throws for a specifier that does not exist', async () => {
+test('throws for a specifier that does not exist', () => {
     let err;
     try {
-        await resolve_node_specifier('@ryanatkn/fuz/this_does_not_exist');
+        resolve_node_specifier('@ryanatkn/fuz/this_does_not_exist');
     }
     catch (_err) {
         err = _err;

package/dist/resolve_specifier.d.ts

@@ -13,4 +13,4 @@ export interface Resolved_Specifier {
  * @param passthrough_extensions - used to support specifiers that have no file extention, which Vite supports, so we do our best effort
  * @returns
  */
-export declare const resolve_specifier: (path: string, dir: string) => Promise<Resolved_Specifier>;
+export declare const resolve_specifier: (path: string, dir: string) => Resolved_Specifier;

package/dist/resolve_specifier.js

@@ -10,7 +10,7 @@ import { replace_extension } from './paths.js';
  * @param passthrough_extensions - used to support specifiers that have no file extention, which Vite supports, so we do our best effort
  * @returns
  */
-export const resolve_specifier = async (path, dir) => {
+export const resolve_specifier = (path, dir) => {
     const absolute_path = isAbsolute(path) ? path : join(dir, path);
     let mapped_path;
     let path_id;

package/dist/resolve_specifier.test.js

@@ -4,60 +4,60 @@ import { join } from 'node:path';
 import { resolve_specifier } from './resolve_specifier.js';
 import { paths } from './paths.js';
 const dir = paths.source + 'fixtures/';
-test('resolves a specifier to a file that exists with an unknown file extension', async () => {
-    assert.equal(await resolve_specifier(join(dir, 'test_file.other.ext'), dir), {
+test('resolves a specifier to a file that exists with an unknown file extension', () => {
+    assert.equal(resolve_specifier(join(dir, 'test_file.other.ext'), dir), {
         specifier: './test_file.other.ext',
         path_id: join(dir, 'test_file.other.ext'),
         namespace: undefined,
     });
 });
-test('resolves a ts specifier', async () => {
-    assert.equal(await resolve_specifier(join(dir, 'test_ts.ts'), dir), {
+test('resolves a ts specifier', () => {
+    assert.equal(resolve_specifier(join(dir, 'test_ts.ts'), dir), {
         specifier: './test_ts.js',
         path_id: join(dir, 'test_ts.ts'),
         namespace: 'sveltekit_local_imports_ts',
     });
 });
-test('resolves relative ts specifiers', async () => {
-    assert.equal(await resolve_specifier('./test_ts.ts', dir), {
+test('resolves relative ts specifiers', () => {
+    assert.equal(resolve_specifier('./test_ts.ts', dir), {
         specifier: './test_ts.js',
         path_id: join(dir, 'test_ts.ts'),
         namespace: 'sveltekit_local_imports_ts',
     });
-    assert.equal(await resolve_specifier('./a/b/test_ts.ts', dir), {
+    assert.equal(resolve_specifier('./a/b/test_ts.ts', dir), {
         specifier: './a/b/test_ts.js',
         path_id: join(dir, 'a/b/test_ts.ts'),
         namespace: 'sveltekit_local_imports_ts',
     });
-    assert.equal(await resolve_specifier('../../test_ts.ts', dir), {
+    assert.equal(resolve_specifier('../../test_ts.ts', dir), {
         specifier: '../../test_ts.js',
         path_id: join(dir, '../../test_ts.ts'),
         namespace: 'sveltekit_local_imports_ts',
     });
 });
-test('resolves an extensionless specifier', async () => {
-    assert.equal(await resolve_specifier(join(dir, 'test_ts'), dir), {
+test('resolves an extensionless specifier', () => {
+    assert.equal(resolve_specifier(join(dir, 'test_ts'), dir), {
         specifier: './test_ts.js',
         path_id: join(dir, 'test_ts.ts'),
         namespace: 'sveltekit_local_imports_ts',
     });
 });
-test('resolves a js specifier', async () => {
-    assert.equal(await resolve_specifier(join(dir, 'test_js.js'), dir), {
+test('resolves a js specifier', () => {
+    assert.equal(resolve_specifier(join(dir, 'test_js.js'), dir), {
         specifier: './test_js.js',
         path_id: join(dir, 'test_js.js'),
         namespace: 'sveltekit_local_imports_js',
     });
 });
-test('resolves a js specifier as ts for a file that does not exist', async () => {
-    assert.equal(await resolve_specifier(join(dir, 'test_missing.js'), dir), {
+test('resolves a js specifier as ts for a file that does not exist', () => {
+    assert.equal(resolve_specifier(join(dir, 'test_missing.js'), dir), {
         specifier: './test_missing.js',
         path_id: join(dir, 'test_missing.ts'),
         namespace: 'sveltekit_local_imports_ts',
     });
 });
-test('resolves an extensionless specifier for a file that does not exist', async () => {
-    assert.equal(await resolve_specifier(join(dir, 'test_missing'), dir), {
+test('resolves an extensionless specifier for a file that does not exist', () => {
+    assert.equal(resolve_specifier(join(dir, 'test_missing'), dir), {
         specifier: './test_missing.js',
         path_id: join(dir, 'test_missing.ts'),
         namespace: 'sveltekit_local_imports_ts',

package/dist/run_gen.test.js

@@ -18,7 +18,7 @@ test__gen('basic behavior', async () => {
     const mod_a = {
         id: path_id_a,
         mod: {
-            gen: async (ctx) => {
+            gen: (ctx) => {
                 assert.is(ctx.origin_id, path_id_a);
                 if (file_a)
                     throw Error('Already generated file_a');
@@ -33,7 +33,7 @@ test__gen('basic behavior', async () => {
     const mod_b = {
         id: join(path_id_bc, 'mod_b.gen.ts'),
         mod: {
-            gen: async (ctx) => {
+            gen: (ctx) => {
                 assert.is(ctx.origin_id, mod_b.id);
                 if (file_b)
                     throw Error('Already generated file_b');
@@ -48,7 +48,7 @@ test__gen('basic behavior', async () => {
     const mod_c = {
         id: join(path_id_bc, 'mod_c.gen.ts'),
         mod: {
-            gen: async (ctx) => {
+            gen: (ctx) => {
                 assert.is(ctx.origin_id, mod_c.id);
                 if (file_c1)
                     throw Error('Already generated file_c1');
@@ -67,7 +67,7 @@ test__gen('basic behavior', async () => {
         },
     };
     const gen_modules_by_input_path = [mod_a, mod_b, mod_c];
-    const gen_results = await run_gen(gen_modules_by_input_path, await load_config(), log, new Timings(), async (content, opts) => opts.filepath.endsWith('output_b.ts') ? `${content}/*FORMATTED*/` : content);
+    const gen_results = await run_gen(gen_modules_by_input_path, await load_config(), log, new Timings(), (content, opts) => Promise.resolve(opts.filepath.endsWith('output_b.ts') ? `${content}/*FORMATTED*/` : content));
     assert.is(gen_results.input_count, 3);
     assert.is(gen_results.output_count, 4);
     assert.is(gen_results.successes.length, 3);
@@ -77,7 +77,7 @@ test__gen('basic behavior', async () => {
     assert.is(gen_results.results[1], gen_results.successes[1]);
     assert.is(gen_results.results[2], gen_results.successes[2]);
     const result_a = gen_results.results[0];
-    assert.ok(result_a?.ok);
+    assert.ok(result_a.ok);
     assert.ok(file_a);
     assert.equal(result_a.files, [
         {
@@ -88,7 +88,7 @@ test__gen('basic behavior', async () => {
         },
     ]);
     const result_b = gen_results.results[1];
-    assert.ok(result_b?.ok);
+    assert.ok(result_b.ok);
     assert.ok(file_b);
     assert.equal(result_b.files, [
         {
@@ -99,7 +99,7 @@ test__gen('basic behavior', async () => {
         },
     ]);
     const result_c = gen_results.results[2];
-    assert.ok(result_c?.ok);
+    assert.ok(result_c.ok);
     assert.ok(file_c1);
     assert.ok(file_c2);
     assert.equal(result_c.files, [
@@ -127,7 +127,7 @@ test__gen('failing gen function', async () => {
     const mod_a = {
         id: path_id_a,
         mod: {
-            gen: async () => {
+            gen: () => {
                 genError = Error('This fails for testing');
                 throw genError;
             },
@@ -136,7 +136,7 @@ test__gen('failing gen function', async () => {
     const mod_b = {
         id: join(path_idB, 'mod_b.gen.ts'),
         mod: {
-            gen: async (ctx) => {
+            gen: (ctx) => {
                 assert.is(ctx.origin_id, mod_b.id);
                 if (file_b)
                     throw Error('Already generated file_b');
@@ -159,11 +159,11 @@ test__gen('failing gen function', async () => {
     assert.is(gen_results.results[1], gen_results.successes[0]);
     const result_a = gen_results.results[0];
     assert.ok(result_a);
-    assert.ok(!result_a?.ok);
+    assert.ok(!result_a.ok);
     assert.ok(result_a.reason);
     assert.ok(result_a.error);
     const result_b = gen_results.results[1];
-    assert.ok(result_b?.ok);
+    assert.ok(result_b.ok);
     assert.ok(file_b);
     assert.equal(result_b.files, [
         {

package/dist/run_task.js

@@ -30,7 +30,7 @@ export const run_task = async (task_meta, unparsed_args, invoke_task, config, ti
             sveltekit_config: sveltekit_config_global,
             log,
             timings,
-            invoke_task: (invoked_task_name, invoked_args, invoked_config) => invoke_task(invoked_task_name, invoked_args, invoked_config || config, timings),
+            invoke_task: (invoked_task_name, invoked_args, invoked_config) => invoke_task(invoked_task_name, invoked_args, invoked_config ?? config, timings),
         });
     }
     catch (err) {

package/dist/run_task.test.js

@@ -32,9 +32,10 @@ test('invokes a sub task', async () => {
                 },
             },
         },
-    }, args, async (invoking_task_name, invoking_args) => {
+    }, args, (invoking_task_name, invoking_args) => {
         invoked_task_name = invoking_task_name;
         invoked_args = invoking_args;
+        return Promise.resolve();
     }, await load_config(), new Timings());
     assert.ok(result.ok);
     assert.is(invoked_task_name, 'bar/testTask');
@@ -48,7 +49,7 @@ test('failing task', async () => {
         id: 'foo/testTask',
         mod: {
             task: {
-                run: async () => {
+                run: () => {
                     err = Error();
                     throw err;
                 },

package/dist/src_json.d.ts

@@ -248,9 +248,7 @@ export declare const Src_Json: z.ZodIntersection<z.ZodRecord<z.ZodString, z.ZodU
     }, z.ZodTypeAny, "passthrough">>>>;
 }, z.ZodTypeAny, "passthrough">>>;
 export type Src_Json = z.infer<typeof Src_Json>;
-export interface Map_Src_Json {
-    (src_json: Src_Json): Src_Json | null | Promise<Src_Json | null>;
-}
-export declare const create_src_json: (package_json: Package_Json, log?: any, lib_path?: string) => Promise<Src_Json>;
+export type Map_Src_Json = (src_json: Src_Json) => Src_Json | null | Promise<Src_Json | null>;
+export declare const create_src_json: (package_json: Package_Json, log?: any, lib_path?: string) => Src_Json;
 export declare const serialize_src_json: (src_json: Src_Json) => string;
-export declare const to_src_modules: (exports: Package_Json_Exports | undefined, log?: any, lib_path?: string) => Promise<Src_Modules | undefined>;
+export declare const to_src_modules: (exports: Package_Json_Exports | undefined, log?: any, lib_path?: string) => Src_Modules | undefined;

package/dist/src_json.js

@@ -32,23 +32,22 @@ z
     modules: Src_Modules.transform(transform_empty_object_to_undefined).optional(),
 })
     .passthrough());
-export const create_src_json = async (package_json, log, lib_path) => {
-    return Src_Json.parse({
-        name: package_json.name,
-        version: package_json.version,
-        modules: await to_src_modules(package_json.exports, log, lib_path),
-    });
-};
+export const create_src_json = (package_json, log, lib_path) => Src_Json.parse({
+    name: package_json.name,
+    version: package_json.version,
+    modules: to_src_modules(package_json.exports, log, lib_path),
+});
 export const serialize_src_json = (src_json) => {
     const parsed = Src_Json.parse(src_json); // TODO can parse do the logic that normalize does? see `.transform`
     return JSON.stringify(parsed, null, 2) + '\n';
 };
-export const to_src_modules = async (exports, log, lib_path = paths.lib) => {
+export const to_src_modules = (exports, log, lib_path = paths.lib) => {
     if (!exports)
-        return undefined;
+        return;
     const project = new Project();
     project.addSourceFilesAtPaths('src/**/*.ts'); // TODO dir? maybe rewrite with `lib_path`?
-    return Object.fromEntries((await Promise.all(Object.entries(exports).map(async ([k, _v]) => {
+    return Object.fromEntries(Object.entries(exports)
+        .map(([k, _v]) => {
         // TODO hacky - doesn't handle any but the normal mappings, also add a helper?
         const source_file_path = k === '.' || k === './'
             ? 'index.ts'
@@ -68,8 +67,6 @@ export const to_src_modules = async (exports, log, lib_path = paths.lib) => {
         const source_file = project.getSourceFile((f) => f.getFilePath().endsWith(source_file_path)); // TODO expected this to work without the callback, according to my read of the docs it is, but `project.getSourceFile(source_file_path)` fails
         if (source_file) {
             for (const [name, decls] of source_file.getExportedDeclarations()) {
-                if (!decls)
-                    continue;
                 // TODO how to correctly handle multiples?
                 for (const decl of decls) {
                     // TODO helper
@@ -106,5 +103,6 @@ export const to_src_modules = async (exports, log, lib_path = paths.lib) => {
         }
         const src_module = { path: source_file_path, declarations };
         return [k, src_module];
-    }))).filter(Boolean));
+    })
+        .filter((v) => v !== null));
 };

package/dist/src_json.test.js

@@ -3,8 +3,8 @@ import * as assert from 'uvu/assert';
 import { to_src_modules } from './src_json.js';
 import { to_package_exports } from './package_json.js';
 import { paths } from './paths.js';
-test('to_package_modules', async () => {
-    assert.equal(await to_src_modules(to_package_exports([
+test('to_package_modules', () => {
+    assert.equal(to_src_modules(to_package_exports([
         'fixtures/modules/some_test_css.css',
         'fixtures/modules/Some_Test_Svelte.svelte',
         'fixtures/modules/some_test_ts.ts',

package/dist/sveltekit_config.js

@@ -13,7 +13,7 @@ export const load_sveltekit_config = async (dir = process.cwd()) => {
     try {
         return (await import(join(dir, SVELTEKIT_CONFIG_FILENAME))).default;
     }
-    catch (err) {
+    catch (_err) {
         return null;
     }
 };

package/dist/sveltekit_helpers.d.ts

@@ -7,12 +7,12 @@ export declare const SVELTE_CHECK_CLI = "svelte-check";
 export declare const SVELTE_PACKAGE_CLI = "svelte-package";
 export declare const SVELTE_PACKAGE_DEP_NAME = "@sveltejs/package";
 export declare const VITE_CLI = "vite";
-export declare const has_sveltekit_app: () => Promise<Result<object, {
+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) => Promise<Result<object, {
+}>;
+export declare const has_sveltekit_library: (package_json?: Package_Json, sveltekit_config?: Parsed_Sveltekit_Config) => Result<object, {
     message: string;
-}>>;
+}>;
 export declare const sveltekit_sync: (sveltekit_cli?: string | Cli) => Promise<void>;
 /**
  * If the SvelteKit CLI is found and its `.svelte-kit` directory is not, run `svelte-kit sync`.

package/dist/sveltekit_helpers.js

@@ -9,22 +9,22 @@ export const SVELTE_CHECK_CLI = 'svelte-check';
 export const SVELTE_PACKAGE_CLI = 'svelte-package';
 export const SVELTE_PACKAGE_DEP_NAME = '@sveltejs/package';
 export const VITE_CLI = 'vite';
-export const has_sveltekit_app = async () => {
+export const has_sveltekit_app = () => {
     if (!existsSync(SVELTEKIT_CONFIG_FILENAME)) {
         return { ok: false, message: `no SvelteKit config found at ${SVELTEKIT_CONFIG_FILENAME}` };
     }
     // TODO check for routes?
     return { ok: true };
 };
-export const has_sveltekit_library = async (package_json, sveltekit_config = sveltekit_config_global) => {
-    const has_sveltekit_app_result = await has_sveltekit_app();
+export const has_sveltekit_library = (package_json, sveltekit_config = sveltekit_config_global) => {
+    const has_sveltekit_app_result = has_sveltekit_app();
     if (!has_sveltekit_app_result.ok) {
         return has_sveltekit_app_result;
     }
     if (!existsSync(sveltekit_config.lib_path)) {
         return { ok: false, message: `no SvelteKit lib directory found at ${sveltekit_config.lib_path}` };
     }
-    const pkg = package_json ?? (await load_package_json());
+    const pkg = package_json ?? load_package_json();
     if (!(pkg.devDependencies?.[SVELTE_PACKAGE_DEP_NAME] || pkg.dependencies?.[SVELTE_PACKAGE_DEP_NAME])) {
         return {
             ok: false,

package/dist/sveltekit_shim_env.d.ts

@@ -1,4 +1,4 @@
 /**
  * Generates a module shim for SvelteKit's `$env` imports.
  */
-export declare const render_env_shim_module: (dev: boolean, mode: "static" | "dynamic", visibility: "public" | "private", public_prefix?: string, private_prefix?: string, env_dir?: string, env_files?: string[], ambient_env?: Record<string, string | undefined>) => Promise<string>;
+export declare const render_env_shim_module: (dev: boolean, mode: "static" | "dynamic", visibility: "public" | "private", public_prefix?: string, private_prefix?: string, env_dir?: string, env_files?: string[], ambient_env?: Record<string, string | undefined>) => string;

package/dist/sveltekit_shim_env.js

@@ -3,8 +3,8 @@ import { load_env } from './env.js';
 /**
  * Generates a module shim for SvelteKit's `$env` imports.
  */
-export const render_env_shim_module = async (dev, mode, visibility, public_prefix = 'PUBLIC_', private_prefix = '', env_dir, env_files, ambient_env) => {
-    const env = await load_env(dev, visibility, public_prefix, private_prefix, env_dir, env_files, ambient_env);
+export const render_env_shim_module = (dev, mode, visibility, public_prefix = 'PUBLIC_', private_prefix = '', env_dir, env_files, ambient_env) => {
+    const env = load_env(dev, visibility, public_prefix, private_prefix, env_dir, env_files, ambient_env);
     if (mode === 'static') {
         return `// shim for $env/static/${visibility}
 // @see https://github.com/sveltejs/kit/issues/1485

package/dist/task.d.ts

@@ -10,7 +10,7 @@ import { type Input_Path, type Resolved_Input_File, type Resolved_Input_Path } f
 import { type Load_Modules_Failure, type Module_Meta } from './modules.js';
 export interface Task<T_Args = Args, // same as `z.infer<typeof Args>`
 T_Args_Schema extends z.ZodType = z.ZodType, T_Return = unknown> {
-    run: (ctx: Task_Context<T_Args>) => Promise<T_Return>;
+    run: (ctx: Task_Context<T_Args>) => T_Return | Promise<T_Return>;
     summary?: string;
     Args?: T_Args_Schema;
 }

package/dist/task.js

@@ -17,7 +17,12 @@ export const to_task_name = (id, task_root_dir, input_path, root_path) => {
         task_name = strip_end(task_name, suffix);
     }
     if (isAbsolute(input_path)) {
-        return relative(root_path, join(input_path, task_name));
+        // is a bit hacky, but does what we want
+        const relative_to_root = relative(root_path, join(task_root_dir, task_name));
+        if (relative_to_root.startsWith('node_modules/')) {
+            return task_name;
+        }
+        return relative_to_root;
     }
     return task_name;
 };

package/dist/task.test.js

@@ -20,6 +20,11 @@ test('to_task_name basic behavior', () => {
     assert.is(to_task_name('/a/b/c/foo.task.ts', '/a/b', '/a/b', '/a/b/d'), '../c/foo');
     assert.is(to_task_name('/a/b/c/foo.task.ts', '/a/b', '/a/b', '/a/b'), 'c/foo');
     assert.is(to_task_name('/a/b/c/foo.task.ts', '/a/b', '/a/b', '/a/b/c'), 'foo');
+    assert.is(to_task_name('/a/b/d/foo.task.js', '/a/b/d', '/a/b/d/foo', '/a/c'), '../b/d/foo');
+    assert.is(to_task_name('/a/node_modules/b/c/foo.task.js', '/a/node_modules/b/c', '/a/node_modules/b/c/foo', '/a'), 'foo');
+    assert.is(to_task_name('/a/node_modules/b/c/foo.task.js', '/a/node_modules/b/c/', // compared to the above, adds a trailing slash here
+    '/a/node_modules/b/c/foo', '/a'), 'foo');
+    assert.is(to_task_name('/a/node_modules/b/c/foo.task.js', '/a/node_modules/b/c', '/a/node_modules/b/c/foo', '/a/'), 'foo');
     assert.is(to_task_name(resolve('a/b'), resolve('b'), '', ''), resolve('a/b'), 'falls back to the id when unresolved');
 });
 // TODO if we import directly, svelte-package generates types in `src/fixtures`

package/dist/task_logging.d.ts

@@ -1,5 +1,5 @@
 import type { Logger } from '@ryanatkn/belt/log.js';
 import type { Loaded_Tasks, Task_Module_Meta } from './task.js';
-export declare const log_tasks: (log: Logger, loaded_tasks: Loaded_Tasks, log_intro?: boolean) => Promise<void>;
+export declare const log_tasks: (log: Logger, loaded_tasks: Loaded_Tasks, log_intro?: boolean) => void;
 export declare const log_error_reasons: (log: Logger, reasons: string[]) => void;
 export declare const log_task_help: (log: Logger, meta: Task_Module_Meta) => void;