@opencode-ai/util 0.0.0-dev-18909 → 0.0.0-dev-18952

package/dist/npm.d.ts

@@ -9,23 +9,17 @@ declare const InstallFailedError_base: Schema.Class<InstallFailedError, Schema.T
 }>, import("effect/Cause").YieldableError>;
 export declare class InstallFailedError extends InstallFailedError_base {
 }
-export interface EntryPoint {
+export interface Package {
     readonly directory: string;
-    readonly entrypoint?: string;
+    readonly name: string;
     readonly version?: string;
     readonly revision?: string;
 }
 export interface Interface {
-    readonly add: (pkg: string, options?: {
-        readonly subpaths?: readonly string[];
-    }) => Effect.Effect<EntryPoint, InstallFailedError | EffectFlock.LockError>;
-    readonly resolve: (pkg: string, options?: {
-        readonly subpaths?: readonly string[];
-    }) => Effect.Effect<EntryPoint>;
+    readonly add: (pkg: string) => Effect.Effect<Package, InstallFailedError | EffectFlock.LockError>;
+    readonly resolve: (pkg: string) => Effect.Effect<Package>;
     readonly check: (pkg: string) => Effect.Effect<boolean, InstallFailedError>;
-    readonly update: (pkg: string, options?: {
-        readonly subpaths?: readonly string[];
-    }) => Effect.Effect<EntryPoint, InstallFailedError | EffectFlock.LockError>;
+    readonly update: (pkg: string) => Effect.Effect<Package, InstallFailedError | EffectFlock.LockError>;
     readonly which: (pkg: string, bin?: string) => Effect.Effect<string | undefined>;
 }
 declare const Service_base: Context.ServiceClass<Service, "@opencode/Npm", Interface>;
@@ -36,8 +30,8 @@ export declare function isRegistryPackage(pkg: string): Promise<boolean>;
 export declare function isInstallablePackage(pkg: string): Promise<boolean>;
 export declare function cacheKey(pkg: string): Promise<string>;
 export declare const node: LayerNode.Provider<Service, never, LayerNode.Tag<"global">>;
-export declare function add(...args: Parameters<Interface["add"]>): Promise<EntryPoint>;
-export declare function resolve(...args: Parameters<Interface["resolve"]>): Promise<EntryPoint>;
+export declare function add(...args: Parameters<Interface["add"]>): Promise<Package>;
+export declare function resolve(...args: Parameters<Interface["resolve"]>): Promise<Package>;
 export declare function check(...args: Parameters<Interface["check"]>): Promise<boolean>;
-export declare function update(...args: Parameters<Interface["update"]>): Promise<EntryPoint>;
+export declare function update(...args: Parameters<Interface["update"]>): Promise<Package>;
 export declare function which(...args: Parameters<Interface["which"]>): Promise<string | undefined>;

package/dist/npm.js

@@ -10,7 +10,6 @@ import { filesystem } from "./effect/app-node-platform.js";
 import { LayerNode } from "./effect/layer-node.js";
 import { makeRuntime } from "./effect/runtime.js";
 import { NpmConfig } from "./npm-config.js";
-import { resolveModule } from "#runtime-import";
 export class InstallFailedError extends Schema.TaggedError()("NpmInstallFailedError", {
     add: Schema.Array(Schema.String).pipe(Schema.optional),
     dir: Schema.String,
@@ -82,22 +81,6 @@ function gitSlug(pkg) {
         ?.replace(/[^a-zA-Z0-9._-]+/g, "-")
         .replace(/^-+|-+$/g, "") || "repository");
 }
-const resolveEntryPoint = (name, dir, subpaths = [""]) => {
-    const entrypoint = subpaths
-        .map((subpath) => {
-        try {
-            return resolveModule([name, subpath].filter(Boolean).join("/"), dir);
-        }
-        catch {
-            return undefined;
-        }
-    })
-        .find((entrypoint) => entrypoint !== undefined);
-    return {
-        directory: dir,
-        entrypoint,
-    };
-};
 const PackageJson = Schema.Struct({
     dependencies: Schema.optional(Schema.Record(Schema.String, Schema.String)),
     version: Schema.optional(Schema.String),
@@ -155,7 +138,7 @@ const layer = Layer.effect(Service, Effect.gen(function* () {
                 return revision;
         }
     });
-    const entry = Effect.fnUntraced(function* (root, name, dir, target, subpaths) {
+    const metadata = Effect.fnUntraced(function* (root, name, dir, target) {
         const manifest = yield* afs
             .readJson(path.join(dir, "package.json"))
             .pipe(Effect.flatMap(Schema.decodeUnknownEffect(PackageJson)), Effect.option);
@@ -163,7 +146,8 @@ const layer = Layer.effect(Service, Effect.gen(function* () {
         const revision = target ? (yield* installedRevision(root, name, target)) ?? manifestVersion : undefined;
         const version = target?.type === "git" ? revision : manifestVersion;
         return {
-            ...resolveEntryPoint(name, dir, subpaths),
+            directory: dir,
+            name,
             ...(version ? { version } : {}),
             ...(revision ? { revision } : {}),
         };
@@ -198,32 +182,36 @@ const layer = Layer.effect(Service, Effect.gen(function* () {
     }).pipe(Effect.withSpan("Npm.reify", {
         attributes: input,
     }));
-    const install = Effect.fnUntraced(function* (pkg, target, dir, subpaths, update) {
+    const install = Effect.fnUntraced(function* (pkg, target, dir, update) {
         yield* flock.acquire(`npm-install:${dir}`);
         const active = yield* current(dir);
         const name = yield* installedName(pkg, active ?? dir, target);
         if (active && !update && (yield* afs.existsSafe(path.join(active, "node_modules", name)))) {
-            return yield* entry(active, name, path.join(active, "node_modules", name), target, subpaths);
+            return yield* metadata(active, name, path.join(active, "node_modules", name), target);
         }
         yield* mkdir(dir);
         const startedAt = yield* Clock.currentTimeMillis;
-        const staging = path.join(dir, `.staging-${startedAt}-${randomUUID()}`);
+        // Arborist keys lockfile entries relative to the root's real path. When the cache
+        // directory is reached through a symlink (macOS `/var` → `/private/var`, a linked
+        // XDG cache), the keys become `../../…` paths that installedRevision never finds,
+        // so Git checks report "not installed" and updates go undetected. Stage under the
+        // resolved directory so the root path and real path agree.
+        const root = yield* fs.realPath(dir).pipe(Effect.mapError((cause) => new InstallFailedError({ dir, cause })));
+        const staging = path.join(root, `.staging-${startedAt}-${randomUUID()}`);
         const staged = yield* Effect.gen(function* () {
             const tree = yield* reify({ dir: staging, config: dir, add: [pkg], update });
             const installed = tree.edgesOut.values().next().value?.to;
             const installedNameValue = installed?.name ?? (yield* installedName(pkg, staging, target));
-            const result = yield* entry(staging, installedNameValue, installed?.path ?? path.join(staging, "node_modules", installedNameValue), target, 
-            // Resolve installed entrypoints after rename so Bun cannot hold the staging directory open on Windows.
-            installed ? [] : subpaths);
-            if (!installed && !result.entrypoint)
+            const result = yield* metadata(staging, installedNameValue, installed?.path ?? path.join(staging, "node_modules", installedNameValue), target);
+            if (!installed && !(yield* afs.isDir(result.directory)))
                 return yield* new InstallFailedError({ add: [pkg], dir: staging });
             const links = process.platform === "win32"
                 ? Array.from(tree.inventory.values()).filter((node) => node.isLink && FSUtil.contains(staging, node.path) && FSUtil.contains(staging, node.realpath))
                 : [];
-            return { name: installedNameValue, result, links };
+            return { result, links };
         }).pipe(Effect.onError(() => remove(staging, dir).pipe(Effect.ignore)));
         if (active) {
-            const activeEntry = yield* entry(active, name, path.join(active, "node_modules", name), target, subpaths);
+            const activeEntry = yield* metadata(active, name, path.join(active, "node_modules", name), target);
             if (activeEntry.revision && activeEntry.revision === staged.result.revision) {
                 yield* remove(staging, dir);
                 return activeEntry;
@@ -244,7 +232,7 @@ const layer = Layer.effect(Service, Effect.gen(function* () {
             }), { discard: true }).pipe(Effect.onError(() => remove(staging, dir).pipe(Effect.ignore)));
         }
         yield* rename(staging, generation, dir);
-        return yield* entry(generation, staged.name, path.join(generation, "node_modules", staged.name), target, subpaths);
+        return { ...staged.result, directory: path.join(generation, "node_modules", staged.result.name) };
     });
     const collect = Effect.fnUntraced(function* (dir) {
         const now = yield* Clock.currentTimeMillis;
@@ -261,20 +249,20 @@ const layer = Layer.effect(Service, Effect.gen(function* () {
             return remove(path.join(dir, name), dir).pipe(Effect.catchCause((cause) => Effect.logWarning("failed to remove stale npm generation", { dir, name, cause })));
         }, { concurrency: "unbounded", discard: true });
     });
-    const add = Effect.fn("Npm.add")(function* (pkg, options) {
+    const add = Effect.fn("Npm.add")(function* (pkg) {
         const target = yield* Effect.promise(() => parse(pkg));
         const dir = directory(pkg, target);
-        return yield* install(pkg, target, dir, options?.subpaths, false);
+        return yield* install(pkg, target, dir, false);
     }, Effect.scoped);
-    const resolve = Effect.fn("Npm.resolve")(function* (pkg, options) {
+    const resolve = Effect.fn("Npm.resolve")(function* (pkg) {
         const target = yield* Effect.promise(() => parse(pkg));
         const root = directory(pkg, target);
         const generation = yield* current(root);
         const name = yield* installedName(pkg, generation ?? root, target);
         const dir = path.join(generation ?? root, "node_modules", name);
         if (!(yield* afs.existsSafe(dir)))
-            return { directory: dir };
-        return yield* entry(generation ?? root, name, dir, target, options?.subpaths);
+            return { directory: dir, name };
+        return yield* metadata(generation ?? root, name, dir, target);
     });
     const check = Effect.fn("Npm.check")(function* (pkg) {
         const target = yield* Effect.promise(() => parse(pkg));
@@ -301,7 +289,7 @@ const layer = Layer.effect(Service, Effect.gen(function* () {
             return yield* new InstallFailedError({ dir: root, cause: new Error(`Package revision not found: ${pkg}`) });
         return installed !== available;
     });
-    const update = Effect.fn("Npm.update")(function* (pkg, options) {
+    const update = Effect.fn("Npm.update")(function* (pkg) {
         const target = yield* Effect.promise(() => parse(pkg));
         const dir = directory(pkg, target);
         if (!target)
@@ -310,8 +298,8 @@ const layer = Layer.effect(Service, Effect.gen(function* () {
                 cause: new Error("Package updates only support registry and Git package specs"),
             });
         if (!target.mutable)
-            return yield* add(pkg, options);
-        const installed = yield* install(pkg, target, dir, options?.subpaths, true);
+            return yield* add(pkg);
+        const installed = yield* install(pkg, target, dir, true);
         yield* collect(dir);
         return installed;
     }, Effect.scoped);

package/dist/runtime/import.bun.js

@@ -1,6 +1,8 @@
+import { pathToFileURL } from "node:url";
 export function importModule(specifier) {
     return import(specifier);
 }
 export function resolveModule(specifier, directory) {
-    return import.meta.resolve(specifier, directory);
+    const resolved = Bun.resolveSync(specifier, directory);
+    return resolved.startsWith("node:") ? resolved : pathToFileURL(resolved).href;
 }

package/dist/runtime/import.node.js

@@ -1,19 +1,8 @@
 import { Script, constants } from "node:vm";
-import { createRequire, registerHooks } from "node:module";
+import { registerHooks } from "node:module";
+import { statSync } from "node:fs";
 import path from "node:path";
 import { pathToFileURL } from "node:url";
-import { resolve } from "resolve.exports";
-let conditions = [];
-const conditionHooks = registerHooks({
-    resolve(specifier, context, nextResolve) {
-        conditions = context.conditions;
-        return nextResolve(specifier, context);
-    },
-});
-await new Script('import("node:module")', {
-    importModuleDynamically: constants.USE_MAIN_CONTEXT_DEFAULT_LOADER,
-}).runInThisContext();
-conditionHooks.deregister();
 export async function importModule(specifier) {
     const imported = (await new Script(`import(${JSON.stringify(specifier)})`, {
         importModuleDynamically: constants.USE_MAIN_CONTEXT_DEFAULT_LOADER,
@@ -27,10 +16,47 @@ export async function importModule(specifier) {
     return Object.assign({}, module, exports);
 }
 export function resolveModule(specifier, directory) {
-    const pkg = createRequire(import.meta.url)(path.join(directory, "package.json"));
-    const target = resolve(pkg, specifier, { conditions, unsafe: true })?.[0];
-    if (target)
-        return pathToFileURL(path.resolve(directory, target)).href;
-    const legacyTarget = specifier === pkg.name ? directory : path.resolve(directory, specifier.slice(pkg.name.length + 1));
-    return pathToFileURL(createRequire(path.join(directory, "package.json")).resolve(legacyTarget)).href;
+    // Node only accepts import.meta.resolve's parent URL behind an experimental
+    // flag. Scope this synchronous resolution to the caller's package directory
+    // through the supported resolver hook instead.
+    const hook = registerHooks({
+        resolve(specifier, context, nextResolve) {
+            return nextResolve(specifier, { ...context, parentURL: pathToFileURL(path.join(directory, "package.json")).href });
+        },
+    });
+    try {
+        const resolve = (target) => {
+            const resolved = import.meta.resolve(path.isAbsolute(target) ? pathToFileURL(target).href : target);
+            if (resolved.startsWith("file:"))
+                statSync(new URL(resolved));
+            return resolved;
+        };
+        try {
+            return resolve(specifier);
+        }
+        catch (error) {
+            if (path.extname(specifier) || !missing(error))
+                throw error;
+            // Node does not infer extensions for local files or legacy package
+            // subpaths. Resolve each candidate natively so package exports still apply.
+            for (const extension of [".ts", ".tsx", ".js", ".jsx", ".mts", ".mjs", ".cts", ".cjs"]) {
+                try {
+                    return resolve(specifier + extension);
+                }
+                catch (cause) {
+                    if (!missing(cause))
+                        throw cause;
+                }
+            }
+            throw error;
+        }
+    }
+    finally {
+        hook.deregister();
+    }
+}
+function missing(error) {
+    return (error instanceof Error &&
+        "code" in error &&
+        ["ENOENT", "ENOTDIR", "ERR_MODULE_NOT_FOUND"].includes(String(error.code)));
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@opencode-ai/util",
-  "version": "0.0.0-dev-18909",
+  "version": "0.0.0-dev-18952",
   "type": "module",
   "license": "MIT",
   "repository": {
@@ -60,8 +60,7 @@
     "mime-types": "3.0.2",
     "minimatch": "10.2.5",
     "npm-package-arg": "13.0.2",
-    "pacote": "21.5.1",
-    "resolve.exports": "2.0.3"
+    "pacote": "21.5.1"
   },
   "devDependencies": {
     "@tsconfig/bun": "1.0.9",