@opencode/util 0.0.0-dev-21581 → 0.0.0-dev-21590

package/dist/flock.d.ts

@@ -1,4 +1,3 @@
-import { Effect } from "effect";
 export type FlockGlobal = {
     state: string;
 };
@@ -26,5 +25,4 @@ export declare namespace Flock {
     }
     function acquire(key: string, input?: Options): Promise<Lease>;
     function withLock<T>(key: string, fn: () => Promise<T>, input?: Options): Promise<T>;
-    const effect: (key: string, input?: Options | undefined) => Effect.Effect<void, never, import("effect/Scope").Scope>;
 }

package/dist/flock.js

@@ -3,7 +3,6 @@ import os from "os";
 import { randomBytes, randomUUID } from "crypto";
 import { mkdir, readFile, rm, stat, utimes, writeFile } from "fs/promises";
 import { Hash } from "./hash.js";
-import { Effect } from "effect";
 export var Flock;
 (function (Flock) {
     let global;
@@ -265,9 +264,4 @@ export var Flock;
         return await fn();
     }
     Flock.withLock = withLock;
-    Flock.effect = Effect.fn("Flock.effect")(function* (key, input = {}) {
-        return yield* Effect.acquireRelease(Effect.promise((signal) => Flock.acquire(key, { ...input, signal })).pipe(Effect.withSpan("Flock.acquire", {
-            attributes: { key },
-        })), (lock) => Effect.promise(() => lock.release()).pipe(Effect.withSpan("Flock.release"))).pipe(Effect.asVoid);
-    });
 })(Flock || (Flock = {}));

package/dist/fs-util.d.ts

@@ -42,97 +42,12 @@ export declare namespace FSUtil {
     const Service_base: Context.ServiceClass<Service, "@opencode/FSUtil", Interface>;
     export class Service extends Service_base {
     }
-    export const use: {
-        readonly access: (path: string, options?: {
-            readonly ok?: boolean | undefined;
-            readonly readable?: boolean | undefined;
-            readonly writable?: boolean | undefined;
-        } | undefined) => Effect.Effect<void, PlatformError, Service>;
-        readonly copy: (fromPath: string, toPath: string, options?: {
-            readonly overwrite?: boolean | undefined;
-            readonly preserveTimestamps?: boolean | undefined;
-        } | undefined) => Effect.Effect<void, PlatformError, Service>;
-        readonly copyFile: (fromPath: string, toPath: string) => Effect.Effect<void, PlatformError, Service>;
-        readonly chmod: (path: string, mode: number) => Effect.Effect<void, PlatformError, Service>;
-        readonly chown: (path: string, uid: number, gid: number) => Effect.Effect<void, PlatformError, Service>;
-        readonly glob: (pattern: string, options?: {
-            readonly root?: string | undefined;
-            readonly exclude?: ReadonlyArray<string> | undefined;
-        } | undefined) => Effect.Effect<string[], PlatformError, Service>;
-        readonly exists: (path: string) => Effect.Effect<boolean, PlatformError, Service>;
-        readonly link: (fromPath: string, toPath: string) => Effect.Effect<void, PlatformError, Service>;
-        readonly makeDirectory: (path: string, options?: {
-            readonly recursive?: boolean | undefined;
-            readonly mode?: number | undefined;
-        } | undefined) => Effect.Effect<void, PlatformError, Service>;
-        readonly makeTempDirectory: (options?: {
-            readonly directory?: string | undefined;
-            readonly prefix?: string | undefined;
-        } | undefined) => Effect.Effect<string, PlatformError, Service>;
-        readonly makeTempDirectoryScoped: (options?: {
-            readonly directory?: string | undefined;
-            readonly prefix?: string | undefined;
-        } | undefined) => Effect.Effect<string, PlatformError, import("effect/Scope").Scope | Service>;
-        readonly makeTempFile: (options?: {
-            readonly directory?: string | undefined;
-            readonly prefix?: string | undefined;
-            readonly suffix?: string | undefined;
-        } | undefined) => Effect.Effect<string, PlatformError, Service>;
-        readonly makeTempFileScoped: (options?: {
-            readonly directory?: string | undefined;
-            readonly prefix?: string | undefined;
-            readonly suffix?: string | undefined;
-        } | undefined) => Effect.Effect<string, PlatformError, import("effect/Scope").Scope | Service>;
-        readonly open: (path: string, options?: {
-            readonly flag?: FileSystem.OpenFlag | undefined;
-            readonly mode?: number | undefined;
-        } | undefined) => Effect.Effect<FileSystem.File, PlatformError, import("effect/Scope").Scope | Service>;
-        readonly readDirectory: (path: string, options?: {
-            readonly recursive?: boolean | undefined;
-        } | undefined) => Effect.Effect<string[], PlatformError, Service>;
-        readonly readFile: (path: string) => Effect.Effect<Uint8Array<ArrayBufferLike>, PlatformError, Service>;
-        readonly readFileString: (path: string, encoding?: string | undefined) => Effect.Effect<string, PlatformError, Service>;
-        readonly readLink: (path: string) => Effect.Effect<string, PlatformError, Service>;
-        readonly realPath: (path: string) => Effect.Effect<string, PlatformError, Service>;
-        readonly remove: (path: string, options?: {
-            readonly recursive?: boolean | undefined;
-            readonly force?: boolean | undefined;
-        } | undefined) => Effect.Effect<void, PlatformError, Service>;
-        readonly rename: (oldPath: string, newPath: string) => Effect.Effect<void, PlatformError, Service>;
-        readonly stat: (path: string) => Effect.Effect<FileSystem.File.Info, PlatformError, Service>;
-        readonly symlink: (fromPath: string, toPath: string) => Effect.Effect<void, PlatformError, Service>;
-        readonly truncate: (path: string, length?: number | undefined) => Effect.Effect<void, PlatformError, Service>;
-        readonly utimes: (path: string, atime: number | Date, mtime: number | Date) => Effect.Effect<void, PlatformError, Service>;
-        readonly writeFile: (path: string, data: Uint8Array<ArrayBufferLike>, options?: {
-            readonly flag?: FileSystem.OpenFlag | undefined;
-            readonly mode?: number | undefined;
-        } | undefined) => Effect.Effect<void, PlatformError, Service>;
-        readonly writeFileString: (path: string, data: string, options?: {
-            readonly flag?: FileSystem.OpenFlag | undefined;
-            readonly mode?: number | undefined;
-        } | undefined) => Effect.Effect<void, PlatformError, Service>;
-        readonly isDir: (path: string) => Effect.Effect<boolean, never, Service>;
-        readonly isFile: (path: string) => Effect.Effect<boolean, never, Service>;
-        readonly existsSafe: (path: string) => Effect.Effect<boolean, never, Service>;
-        readonly readFileStringSafe: (path: string) => Effect.Effect<string | undefined, Error, Service>;
-        readonly readJson: (path: string) => Effect.Effect<unknown, Error, Service>;
-        readonly writeJson: (path: string, data: unknown, mode?: number | undefined) => Effect.Effect<void, Error, Service>;
-        readonly ensureDir: (path: string) => Effect.Effect<void, Error, Service>;
-        readonly writeWithDirs: (path: string, content: string | Uint8Array<ArrayBufferLike>, mode?: number | undefined) => Effect.Effect<void, Error, Service>;
-        readonly readDirectoryEntries: (path: string) => Effect.Effect<DirEntry[], Error, Service>;
-        readonly resolve: (path: string) => Effect.Effect<string, never, Service>;
-        readonly findUp: (target: string, start: string, stop?: string | undefined) => Effect.Effect<string[], Error, Service>;
-        readonly up: (options: UpOptions) => Effect.Effect<string[], Error, Service>;
-        readonly globUp: (pattern: string, start: string, stop?: string | undefined) => Effect.Effect<string[], Error, Service>;
-        readonly scan: (pattern: string, options?: Glob.Options | undefined) => Effect.Effect<string[], Error, Service>;
-    };
     export const layer: Layer.Layer<Service, never, FileSystem.FileSystem>;
     export const node: import("./effect/layer-node.js").Provider<Service, never, import("./effect/layer-node.js").Tag<"global">>;
     /** Permission denial, including macOS sandbox and privacy denials that surface as Unknown with an EPERM cause. */
     export function isAccessDenied(error: PlatformError): boolean;
     export function mimeType(p: string): string;
     export function normalizePath(p: string): string;
-    export function normalizePathPattern(p: string): string;
     export function resolve(p: string): string;
     export function windowsPath(p: string): string;
     export const ignoredDirectories: string[];

package/dist/fs-util.js

@@ -4,7 +4,6 @@ import { readdir } from "fs/promises";
 import { lookup } from "mime-types";
 import { Context, Effect, FileSystem, Layer, Schema } from "effect";
 import { Glob } from "./glob.js";
-import { serviceUse } from "./effect/service-use.js";
 import { makeGlobalNode } from "./effect/app-node.js";
 import { filesystem } from "./effect/app-node-platform.js";
 import { sameDirectory } from "./path.js";
@@ -23,7 +22,6 @@ export var FSUtil;
     class Service extends Context.Service()("@opencode/FSUtil") {
     }
     FSUtil.Service = Service;
-    FSUtil.use = serviceUse(Service);
     // Exported so simulation can wrap this layer and override the methods that
     // bypass the injected FileSystem (readDirectoryEntries, scan, globUp).
     FSUtil.layer = Layer.effect(Service, Effect.gen(function* () {
@@ -185,18 +183,6 @@ export var FSUtil;
         }
     }
     FSUtil.normalizePath = normalizePath;
-    function normalizePathPattern(p) {
-        if (process.platform !== "win32")
-            return p;
-        if (p === "*")
-            return p;
-        const match = p.match(/^(.*)[\\/]\*$/);
-        if (!match)
-            return normalizePath(p);
-        const dir = /^[A-Za-z]:$/.test(match[1]) ? match[1] + "\\" : match[1];
-        return join(normalizePath(dir), "*");
-    }
-    FSUtil.normalizePathPattern = normalizePathPattern;
     function resolve(p) {
         const resolved = path.resolve(windowsPath(p));
         try {

package/dist/glob.d.ts

@@ -8,6 +8,5 @@ export declare namespace Glob {
         ignore?: string[];
     }
     function scan(pattern: string, options?: Options): Promise<string[]>;
-    function scanSync(pattern: string, options?: Options): string[];
     function match(pattern: string, filepath: string): boolean;
 }

package/dist/glob.js

@@ -1,4 +1,4 @@
-import { glob, globSync } from "glob";
+import { glob } from "glob";
 import { minimatch } from "minimatch";
 export var Glob;
 (function (Glob) {
@@ -16,10 +16,6 @@ export var Glob;
         return glob(pattern, toGlobOptions(options));
     }
     Glob.scan = scan;
-    function scanSync(pattern, options = {}) {
-        return globSync(pattern, toGlobOptions(options));
-    }
-    Glob.scanSync = scanSync;
     function match(pattern, filepath) {
         return minimatch(filepath, pattern, { dot: true });
     }

package/dist/npm.d.ts

@@ -1,7 +1,6 @@
 export * as Npm from "./npm.js";
 import { Effect, Schema, Context } from "effect";
 import { EffectFlock } from "./effect-flock.js";
-import { LayerNode } from "./effect/layer-node.js";
 declare const InstallFailedError_base: Schema.Class<InstallFailedError, Schema.TaggedStruct<"NpmInstallFailedError", {
     readonly add: Schema.optional<Schema.$Array<Schema.String>>;
     readonly dir: Schema.String;
@@ -29,9 +28,4 @@ export declare function sanitize(pkg: string): string;
 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<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<Package>;
-export declare function which(...args: Parameters<Interface["which"]>): Promise<string | undefined>;
+export declare const node: import("./effect/layer-node.js").Provider<Service, never, import("./effect/layer-node.js").Tag<"global">>;

package/dist/npm.js

@@ -7,8 +7,6 @@ import { Global } from "./global.js";
 import { EffectFlock } from "./effect-flock.js";
 import { makeGlobalNode } from "./effect/app-node.js";
 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";
 export class InstallFailedError extends Schema.TaggedError()("NpmInstallFailedError", {
     add: Schema.Array(Schema.String).pipe(Schema.optional),
@@ -370,22 +368,6 @@ export const node = makeGlobalNode({
     layer: layer,
     deps: [FSUtil.node, Global.node, filesystem, EffectFlock.node],
 });
-const { runPromise } = makeRuntime(Service, LayerNode.compile(node));
-export async function add(...args) {
-    return runPromise((svc) => svc.add(...args));
-}
-export async function resolve(...args) {
-    return runPromise((svc) => svc.resolve(...args));
-}
-export async function check(...args) {
-    return runPromise((svc) => svc.check(...args));
-}
-export async function update(...args) {
-    return runPromise((svc) => svc.update(...args));
-}
-export async function which(...args) {
-    return runPromise((svc) => svc.which(...args));
-}
 function gitRevision(resolved) {
     return resolved?.match(/#([a-f0-9]{40}|[a-f0-9]{64})(?=::|$)/i)?.[1];
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@opencode/util",
-  "version": "0.0.0-dev-21581",
+  "version": "0.0.0-dev-21590",
   "type": "module",
   "license": "MIT",
   "repository": {

package/dist/effect/memo-map.d.ts

@@ -1,2 +0,0 @@
-import { Layer } from "effect";
-export declare const memoMap: Layer.MemoMap;

package/dist/effect/memo-map.js

@@ -1,2 +0,0 @@
-import { Layer } from "effect";
-export const memoMap = Layer.makeMemoMapUnsafe();

package/dist/effect/runtime.d.ts

@@ -1,8 +0,0 @@
-import { Layer, type Context, type Effect } from "effect";
-export declare function makeRuntime<I, S, E>(service: Context.Service<I, S>, layer: Layer.Layer<I, E>): {
-    runSync: <A, Err>(fn: (svc: S) => Effect.Effect<A, Err, I>) => A;
-    runPromiseExit: <A, Err>(fn: (svc: S) => Effect.Effect<A, Err, I>, options?: Effect.RunOptions) => Promise<import("effect/Exit").Exit<A, E | Err>>;
-    runPromise: <A, Err>(fn: (svc: S) => Effect.Effect<A, Err, I>, options?: Effect.RunOptions) => Promise<A>;
-    runFork: <A, Err>(fn: (svc: S) => Effect.Effect<A, Err, I>) => import("effect/Fiber").Fiber<A, E | Err>;
-    runCallback: <A, Err>(fn: (svc: S) => Effect.Effect<A, Err, I>) => (interruptor?: number | undefined) => void;
-};

package/dist/effect/runtime.js

@@ -1,16 +0,0 @@
-import { Layer, ManagedRuntime } from "effect";
-import { memoMap } from "./memo-map.js";
-import { Observability } from "../observability.js";
-export function makeRuntime(service, layer) {
-    let rt;
-    const getRuntime = () => (rt ??= ManagedRuntime.make(Layer.provideMerge(layer, Observability.layer()), {
-        memoMap,
-    }));
-    return {
-        runSync: (fn) => getRuntime().runSync(service.use(fn)),
-        runPromiseExit: (fn, options) => getRuntime().runPromiseExit(service.use(fn), options),
-        runPromise: (fn, options) => getRuntime().runPromise(service.use(fn), options),
-        runFork: (fn) => getRuntime().runFork(service.use(fn)),
-        runCallback: (fn) => getRuntime().runCallback(service.use(fn)),
-    };
-}

package/dist/effect/service-use.d.ts

@@ -1,7 +0,0 @@
-import { Context, Effect } from "effect";
-type EffectMethod = (...args: ReadonlyArray<never>) => Effect.Effect<unknown, unknown, unknown>;
-type ServiceUse<Identifier, Shape> = {
-    readonly [Key in keyof Shape as Shape[Key] extends EffectMethod ? Key : never]: Shape[Key] extends (...args: infer Args) => infer Return ? Args extends ReadonlyArray<unknown> ? Return extends Effect.Effect<infer A, infer E, infer R> ? (...args: Args) => Effect.Effect<A, E, R | Identifier> : never : never : never;
-};
-export declare const serviceUse: <Identifier, Shape>(tag: Context.Service<Identifier, Shape>) => ServiceUse<Identifier, Shape>;
-export {};

package/dist/effect/service-use.js

@@ -1,27 +0,0 @@
-import { Context, Effect } from "effect";
-export const serviceUse = (tag) => {
-    const cache = new Map();
-    // This is the only dynamic boundary: TypeScript knows the accessor shape,
-    // but Proxy property names are runtime values.
-    const access = new Proxy({}, {
-        get: (_, key) => {
-            if (typeof key !== "string")
-                return undefined;
-            const cached = cache.get(key);
-            if (cached)
-                return cached;
-            const accessor = (...args) => tag.use((service) => {
-                // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Proxy keys are checked at runtime.
-                const method = service[key];
-                if (typeof method !== "function")
-                    return Effect.die(new Error(`Service method not found: ${key}`));
-                // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- ServiceUse exposes only Effect-returning methods.
-                return method(...args);
-            });
-            cache.set(key, accessor);
-            return accessor;
-        },
-    });
-    // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Proxy implements the mapped accessor surface lazily.
-    return access;
-};