npm - @opencode/util - Versions diffs - 0.0.0-beta-19275 - Mend

@opencode/util 0.0.0-beta-19275

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (81) hide show

package/dist/activity-calendar.d.ts +21 -0
package/dist/activity-calendar.js +42 -0
package/dist/activity-calendar.test.d.ts +1 -0
package/dist/activity-calendar.test.js +119 -0
package/dist/binary.d.ts +7 -0
package/dist/binary.js +34 -0
package/dist/binary.test.d.ts +1 -0
package/dist/binary.test.js +16 -0
package/dist/bom.d.ts +22 -0
package/dist/bom.js +36 -0
package/dist/bom.test.d.ts +1 -0
package/dist/bom.test.js +19 -0
package/dist/cross-spawn-spawner.d.ts +3 -0
package/dist/cross-spawn-spawner.js +438 -0
package/dist/effect/app-node-platform.d.ts +6 -0
package/dist/effect/app-node-platform.js +11 -0
package/dist/effect/app-node.d.ts +62 -0
package/dist/effect/app-node.js +8 -0
package/dist/effect/layer-node.d.ts +135 -0
package/dist/effect/layer-node.js +156 -0
package/dist/effect/memo-map.d.ts +2 -0
package/dist/effect/memo-map.js +2 -0
package/dist/effect/runtime.d.ts +8 -0
package/dist/effect/runtime.js +16 -0
package/dist/effect/service-use.d.ts +7 -0
package/dist/effect/service-use.js +27 -0
package/dist/effect-flock.d.ts +31 -0
package/dist/effect-flock.js +186 -0
package/dist/encode.d.ts +4 -0
package/dist/encode.js +38 -0
package/dist/encode.test.d.ts +1 -0
package/dist/encode.test.js +23 -0
package/dist/flock.d.ts +30 -0
package/dist/flock.js +273 -0
package/dist/fs-util.d.ts +137 -0
package/dist/fs-util.js +211 -0
package/dist/glob.d.ts +12 -0
package/dist/glob.js +26 -0
package/dist/global-roots.d.ts +8 -0
package/dist/global-roots.js +17 -0
package/dist/global-roots.workerd.d.ts +7 -0
package/dist/global-roots.workerd.js +15 -0
package/dist/global.d.ts +30 -0
package/dist/global.js +54 -0
package/dist/hash.d.ts +4 -0
package/dist/hash.js +12 -0
package/dist/npm-config.d.ts +4 -0
package/dist/npm-config.js +34 -0
package/dist/npm.d.ts +37 -0
package/dist/npm.js +386 -0
package/dist/observability/logging.d.ts +14 -0
package/dist/observability/logging.js +151 -0
package/dist/observability/otlp.d.ts +18 -0
package/dist/observability/otlp.js +76 -0
package/dist/observability/shared.d.ts +1 -0
package/dist/observability/shared.js +7 -0
package/dist/observability.d.ts +13 -0
package/dist/observability.js +37 -0
package/dist/patch.d.ts +43 -0
package/dist/patch.js +331 -0
package/dist/path.d.ts +4 -0
package/dist/path.js +33 -0
package/dist/path.test.d.ts +1 -0
package/dist/path.test.js +36 -0
package/dist/process.d.ts +54 -0
package/dist/process.js +167 -0
package/dist/retry.d.ts +8 -0
package/dist/retry.js +37 -0
package/dist/retry.test.d.ts +1 -0
package/dist/retry.test.js +31 -0
package/dist/runtime/import.bun.d.ts +2 -0
package/dist/runtime/import.bun.js +8 -0
package/dist/runtime/import.node.d.ts +2 -0
package/dist/runtime/import.node.js +62 -0
package/dist/runtime/import.workerd.d.ts +2 -0
package/dist/runtime/import.workerd.js +7 -0
package/dist/runtime-import.d.ts +1 -0
package/dist/runtime-import.js +1 -0
package/dist/session-title-fallback.d.ts +16 -0
package/dist/session-title-fallback.js +23 -0
package/package.json +75 -0

package/dist/effect/layer-node.d.ts ADDED Viewed

@@ -0,0 +1,135 @@
+import { Brand, Context, Layer } from "effect";
+export * as LayerNode from "./layer-node.js";
+declare const GraphTypeId: unique symbol;
+declare const VarianceTypeId: unique symbol;
+declare const NodeTypeId: unique symbol;
+declare const ReplacementTypeId: unique symbol;
+export type Tag<Name extends string = string> = Name & Brand.Brand<"LayerNode.Tag">;
+export type Graph<A, E = never, T extends Tag | undefined = Tag | undefined> = GraphValue<A, E, T>;
+export type Node<A, E = never, T extends Tag | undefined = undefined> = NodeValue<A, E, T>;
+export type Provider<A, E = never, T extends Tag | undefined = undefined> = ProviderNode<A, E, T>;
+export type Replacement = ReplacementValue;
+export type Replacements = readonly Replacement[];
+type AnyGraph = Graph<never, unknown>;
+type AnyNode = AnyGraph & {
+    readonly [NodeTypeId]: unknown;
+    readonly tag: Tag | undefined;
+};
+type RuntimeLayer = Layer.Layer<never, unknown, unknown>;
+type GraphList = readonly [] | readonly [AnyGraph, ...AnyGraph[]];
+export type Output<Item> = CommonOutput<Item, Item extends Graph<infer A, unknown> ? A : never>;
+export type Error<Item> = Item extends Graph<never, infer E> ? E : never;
+type GraphTag<Item> = [Item] extends [never] ? undefined : Item extends Graph<never, unknown, infer T> ? T : never;
+type CommonOutput<Item, A> = A extends unknown ? ([Item] extends [Graph<A, unknown>] ? A : never) : never;
+type LayerOutput<Item extends Layer.Any, A = Layer.Success<Item>> = A extends unknown ? [Item] extends [Layer.Layer<A, unknown, unknown>] ? A : never : never;
+type ListOutput<Items extends readonly AnyGraph[], A = never> = [Items] extends [
+    readonly [infer Head extends AnyGraph, ...infer Tail extends readonly AnyGraph[]]
+] ? ListOutput<Tail, A | Output<Head>> : A;
+type Definition = {
+    readonly kind: "group";
+    readonly name: string;
+    readonly dependencies: readonly AnyGraph[];
+} | {
+    readonly kind: "unbound";
+    readonly name: string;
+} | {
+    readonly kind: "layer";
+    readonly name: string;
+    readonly implementation: RuntimeLayer;
+    readonly dependencies: readonly AnyGraph[];
+};
+declare class GraphValue<in A, out E, out T extends Tag | undefined> {
+    private readonly graph;
+    readonly [VarianceTypeId]: {
+        readonly output: (_: A) => void;
+        readonly error: () => E;
+        readonly tags: () => T;
+    };
+    readonly [GraphTypeId]: Definition;
+    constructor(definition: Definition);
+    get name(): string;
+}
+declare class NodeValue<in out A, in out E, in out T extends Tag | undefined> extends GraphValue<A, E, T> {
+    readonly tag: T;
+    readonly [NodeTypeId]: (_: [A, E, T]) => [A, E, T];
+    constructor(definition: Exclude<Definition, {
+        kind: "group";
+    }>, tag: T);
+    /** Replace this declaration, including every dependency on it, without acquiring its old wiring. */
+    replace<const Target extends AnyNode | Layer.Any>(this: Node<A, E, T>, replacement: Target & CheckReplacement<A, E, T, Target>): Replacement;
+}
+declare class ProviderNode<in out A, in out E, in out T extends Tag | undefined> extends NodeValue<A, E, T> {
+    /** Decorate the implementation while preserving its dependency wiring and service contract. */
+    mapLayer(this: Provider<A, E, T>, f: <R>(layer: Layer.Layer<A, E, R>) => Layer.Layer<A, E, R>): Provider<A, E, T>;
+}
+declare class ReplacementValue {
+    private readonly checked;
+    readonly [ReplacementTypeId]: {
+        readonly source: AnyNode;
+        readonly target: AnyNode;
+    };
+    constructor(source: AnyNode, target: AnyNode);
+}
+type CheckErrors<Expected, Actual> = [Exclude<Actual, Expected>] extends [never] ? never : {
+    readonly "New replacement errors": Exclude<Actual, Expected>;
+};
+type CheckReplacement<A, E, T, Target> = [ReplacementErrors<A, E, T, Target>] extends [never] ? unknown : ReplacementErrors<A, E, T, Target>;
+type ReplacementErrors<A, E, T, Target> = Target extends AnyNode ? [Exclude<A, Output<Target>>] extends [never] ? [GraphTag<Target>] extends [T] ? CheckErrors<E, Error<Target>> : {
+    readonly "Invalid replacement tag": GraphTag<Target>;
+} : {
+    readonly "Missing replacement outputs": Exclude<A, Output<Target>>;
+} : Target extends Layer.Layer<A, infer E2, never> ? CheckErrors<E, E2> : {
+    readonly "Replacement must be a closed layer": Target;
+};
+type CheckDependencies<Implementation extends Layer.Any, Items extends GraphList> = [
+    Exclude<Layer.Services<Implementation>, ListOutput<Items>>
+] extends [never] ? unknown : {
+    readonly "Missing dependencies": Exclude<Layer.Services<Implementation>, ListOutput<Items>>;
+};
+type Identity = {
+    readonly service: Context.Service.Any;
+    readonly name?: never;
+} | {
+    readonly name: string;
+    readonly service?: never;
+};
+type CheckLayer<Implementation> = [Implementation] extends [RuntimeLayer] ? unknown : {
+    readonly "Layer contract must be preserved": Implementation;
+};
+type TagInput<T> = {
+    readonly tag: T;
+} | ([T] extends [undefined] ? {
+    readonly tag?: undefined;
+} : never);
+type MakeInput<Implementation extends Layer.Any, Items extends GraphList, T extends Tag | undefined> = Identity & TagInput<T> & {
+    readonly layer: Implementation & CheckLayer<NoInfer<Implementation>>;
+    readonly deps: Items & CheckDependencies<Implementation, NoInfer<Items>>;
+};
+type DistributiveOmit<A, K extends PropertyKey> = A extends unknown ? Omit<A, K> : never;
+export type TagConfig = Readonly<Record<string, readonly string[]>>;
+type TagNames<Config extends TagConfig> = keyof Config & string;
+type CheckTags<Items extends GraphList, Names extends string> = [
+    Exclude<GraphTag<Items[number]>, Tag<Names> | undefined>
+] extends [never] ? unknown : {
+    readonly "Invalid tag dependencies": Exclude<GraphTag<Items[number]>, Tag<Names> | undefined>;
+};
+export interface Tags<Config extends TagConfig> {
+    readonly values: {
+        readonly [Name in TagNames<Config>]: Tag<Name>;
+    };
+    readonly make: <Name extends TagNames<Config>>(name: Name) => <const Implementation extends Layer.Any, const Items extends GraphList>(input: DistributiveOmit<MakeInput<Implementation, Items, Tag<Name>>, "tag"> & CheckTags<Items, Name | Extract<Config[Name][number], string>>) => Provider<LayerOutput<Implementation>, Layer.Error<Implementation> | Error<Items[number]>, Tag<Name>>;
+}
+export declare function tags<const Config extends {
+    readonly [Name in keyof Config]: readonly (keyof Config & string)[];
+}>(config: Config): Tags<Config>;
+export declare function make<const Implementation extends Layer.Any, const Items extends GraphList, const T extends Tag | undefined = undefined>(input: MakeInput<Implementation, Items, T>): Provider<LayerOutput<Implementation>, Layer.Error<Implementation> | Error<Items[number]>, T>;
+export declare function unbound<R, Shape, const T extends Tag>(service: Context.Key<R, Shape>, tag: T): Node<R, never, T>;
+/** Ordered, associative composition. Only these roots' outputs are exposed; their dependencies remain private. */
+export declare function group<const Items extends readonly AnyGraph[]>(dependencies: Items): Graph<ListOutput<Items>, Error<Items[number]>, GraphTag<Items[number]>>;
+export interface CompileOptions {
+    readonly replacements?: Replacements;
+    /** Share subgraphs rooted at this tag; give the remaining wiring a fresh map for each build. */
+    readonly shared?: Tag;
+}
+/** Resolve the final overrides before validating or acquiring anything. Effect owns acquisition and finalization. */
+export declare function compile<A, E>(root: Graph<A, E>, options?: CompileOptions): Layer.Layer<A, E>;

package/dist/effect/layer-node.js ADDED Viewed

@@ -0,0 +1,156 @@
+import { Brand, Context, Effect, Layer } from "effect";
+export * as LayerNode from "./layer-node.js";
+const GraphTypeId = Symbol("LayerNode.Graph");
+const VarianceTypeId = Symbol("LayerNode.Variance");
+const NodeTypeId = Symbol("LayerNode.Node");
+const ReplacementTypeId = Symbol("LayerNode.Replacement");
+const makeTag = Brand.nominal();
+class GraphValue {
+    [GraphTypeId];
+    constructor(definition) {
+        this[GraphTypeId] = definition;
+    }
+    get name() {
+        return this[GraphTypeId].name;
+    }
+}
+class NodeValue extends GraphValue {
+    tag;
+    constructor(definition, tag) {
+        super(definition);
+        this.tag = tag;
+    }
+    /** Replace this declaration, including every dependency on it, without acquiring its old wiring. */
+    replace(replacement) {
+        if (replacement instanceof NodeValue) {
+            if (replacement.tag !== this.tag)
+                throw new Error(`Cannot replace ${this.name} across tags`);
+            return new ReplacementValue(this, replacement);
+        }
+        if (!Layer.isLayer(replacement))
+            throw new Error("A replacement must be a node or an Effect Layer");
+        return new ReplacementValue(this, makeProvider({ name: this.name, layer: replacement, deps: [] }, this.tag));
+    }
+}
+class ProviderNode extends NodeValue {
+    /** Decorate the implementation while preserving its dependency wiring and service contract. */
+    mapLayer(f) {
+        const definition = this[GraphTypeId];
+        if (definition.kind !== "layer")
+            throw new Error(`Cannot map unbound layer node: ${this.name}`);
+        return new ProviderNode({ ...definition, implementation: f(definition.implementation) }, this.tag);
+    }
+}
+class ReplacementValue {
+    [ReplacementTypeId];
+    constructor(source, target) {
+        this[ReplacementTypeId] = { source, target };
+    }
+}
+export function tags(config) {
+    const names = Object.keys(config);
+    const values = Object.fromEntries(names.map((name) => [name, makeTag(name)]));
+    return {
+        values,
+        make: (name) => (input) => makeProvider(input, values[name]),
+    };
+}
+export function make(input) {
+    return makeProvider(input, input.tag);
+}
+function makeProvider(input, tag) {
+    if (!Layer.isLayer(input.layer))
+        throw new Error("A layer node requires an Effect Layer");
+    return new ProviderNode({
+        kind: "layer",
+        name: input.service !== undefined ? input.service.key : input.name,
+        implementation: input.layer,
+        dependencies: [...input.deps],
+    }, tag);
+}
+export function unbound(service, tag) {
+    return new NodeValue({ kind: "unbound", name: service.key }, tag);
+}
+/** Ordered, associative composition. Only these roots' outputs are exposed; their dependencies remain private. */
+export function group(dependencies) {
+    return new GraphValue({ kind: "group", name: "group", dependencies: [...dependencies] });
+}
+/** Resolve the final overrides before validating or acquiring anything. Effect owns acquisition and finalization. */
+export function compile(root, options = {}) {
+    const shared = options.shared;
+    const replacements = new Map(options.replacements?.map((item) => {
+        const replacement = item[ReplacementTypeId];
+        return [replacement.source, replacement.target];
+    }));
+    const cache = {
+        shared: new Map(),
+        local: new Map(),
+    };
+    const stack = [];
+    const definitions = { shared: new Map(), local: new Map() };
+    const resolve = (graph, inherited = false) => {
+        const definition = graph[GraphTypeId];
+        const isShared = inherited || (shared !== undefined && graph instanceof NodeValue && graph.tag === shared);
+        const resolved = isShared ? cache.shared : cache.local;
+        const cached = resolved.get(graph);
+        if (cached)
+            return cached;
+        const cycle = stack.indexOf(graph);
+        if (cycle !== -1) {
+            throw new Error(`Cycle detected in layer graph: ${[...stack.slice(cycle), graph].map((item) => item.name).join(" -> ")}`);
+        }
+        stack.push(graph);
+        const replacement = replacements.get(graph);
+        const result = (() => {
+            if (replacement && replacement !== graph)
+                return resolve(replacement, isShared);
+            if (definition.kind === "group")
+                return definition.dependencies.flatMap((dependency) => resolve(dependency, isShared));
+            if (definition.kind === "unbound")
+                throw new Error(`Unbound layer node: ${definition.name}`);
+            const node = {
+                implementation: definition.implementation,
+                dependencies: definition.dependencies.flatMap((dependency) => resolve(dependency, isShared)),
+                shared: isShared,
+            };
+            const registry = node.shared ? definitions.shared : definitions.local;
+            const existing = registry.get(node.implementation);
+            if (existing) {
+                if (existing.dependencies.length !== node.dependencies.length ||
+                    existing.dependencies.some((dependency, index) => dependency !== node.dependencies[index])) {
+                    throw new Error(`Layer ${definition.name} is wired to different dependencies; use a distinct implementation Layer`);
+                }
+                return [existing];
+            }
+            registry.set(node.implementation, node);
+            return [node];
+        })();
+        stack.pop();
+        resolved.set(graph, result);
+        return result;
+    };
+    const roots = resolve(root);
+    return Layer.fromBuild((memoMap, scope) => {
+        const local = shared === undefined ? memoMap : Layer.makeMemoMapUnsafe();
+        const ambient = Layer.succeed(Layer.CurrentMemoMap, memoMap);
+        const layers = new Map();
+        const build = (node) => {
+            const cached = layers.get(node);
+            if (cached)
+                return cached;
+            const dependencies = node.dependencies.map(build);
+            // Acquisition uses the selected cache, while lazy LayerMaps inherit the enclosing shared cache.
+            const implementation = Layer.suspend(() => node.implementation.pipe(Layer.provide([ambient, ...dependencies])));
+            const layer = Layer.fromBuild((_, scope) => buildContext(implementation, node.shared ? memoMap : local, scope));
+            layers.set(node, layer);
+            return layer;
+        };
+        return buildContext(roots.map(build).reduce((result, layer) => layer.pipe(Layer.provideMerge(result)), Layer.empty), memoMap, scope);
+    });
+}
+class BuildResult extends Context.Service()("@opencode/LayerNode/BuildResult") {
+}
+function buildContext(layer, memoMap, scope) {
+    // Preserve the exact output context before Effect appends its own memo-map metadata.
+    return Layer.buildWithMemoMap(layer.pipe(Layer.flatMap((context) => Layer.succeed(BuildResult, context))), memoMap, scope).pipe(Effect.map(Context.get(BuildResult)));
+}

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

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

package/dist/effect/memo-map.js ADDED Viewed

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

package/dist/effect/runtime.d.ts ADDED Viewed

@@ -0,0 +1,8 @@
+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 ADDED Viewed

@@ -0,0 +1,16 @@
+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 ADDED Viewed

@@ -0,0 +1,7 @@
+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 ADDED Viewed

@@ -0,0 +1,27 @@
+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;
+};

package/dist/effect-flock.d.ts ADDED Viewed

@@ -0,0 +1,31 @@
+import { Context, Effect, Schema } from "effect";
+import type { Scope } from "effect";
+export declare namespace EffectFlock {
+    const LockTimeoutError_base: Schema.Class<LockTimeoutError, Schema.TaggedStruct<"LockTimeoutError", {
+        readonly key: Schema.String;
+    }>, import("effect/Cause").YieldableError>;
+    export class LockTimeoutError extends LockTimeoutError_base {
+    }
+    const LockCompromisedError_base: Schema.Class<LockCompromisedError, Schema.TaggedStruct<"LockCompromisedError", {
+        readonly detail: Schema.String;
+    }>, import("effect/Cause").YieldableError>;
+    export class LockCompromisedError extends LockCompromisedError_base {
+    }
+    export type LockError = LockTimeoutError | LockCompromisedError;
+    export interface Options {
+        readonly staleMs?: number;
+        readonly timeoutMs?: number;
+    }
+    export interface Interface {
+        readonly acquire: (key: string, dir?: string, options?: Options) => Effect.Effect<void, LockError, Scope.Scope>;
+        readonly withLock: {
+            (key: string, dir?: string): <A, E, R>(body: Effect.Effect<A, E, R>) => Effect.Effect<A, E | LockError, R>;
+            <A, E, R>(body: Effect.Effect<A, E, R>, key: string, dir?: string): Effect.Effect<A, E | LockError, R>;
+        };
+    }
+    const Service_base: Context.ServiceClass<Service, "EffectFlock", Interface>;
+    export class Service extends Service_base {
+    }
+    export const node: import("./effect/layer-node.js").Provider<Service, never, import("./effect/layer-node.js").Tag<"global">>;
+    export {};
+}

package/dist/effect-flock.js ADDED Viewed

@@ -0,0 +1,186 @@
+import path from "path";
+import os from "os";
+import { randomUUID } from "crypto";
+import { Context, Effect, Function, Layer, Option, Schedule, Schema } from "effect";
+import { FSUtil } from "./fs-util.js";
+import { Global } from "./global.js";
+import { makeGlobalNode } from "./effect/app-node.js";
+import { Hash } from "./hash.js";
+export var EffectFlock;
+(function (EffectFlock) {
+    // ---------------------------------------------------------------------------
+    // Errors
+    // ---------------------------------------------------------------------------
+    class LockTimeoutError extends Schema.TaggedError()("LockTimeoutError", {
+        key: Schema.String,
+    }) {
+    }
+    EffectFlock.LockTimeoutError = LockTimeoutError;
+    class LockCompromisedError extends Schema.TaggedError()("LockCompromisedError", {
+        detail: Schema.String,
+    }) {
+    }
+    EffectFlock.LockCompromisedError = LockCompromisedError;
+    class ReleaseError extends Schema.TaggedError()("ReleaseError", {
+        detail: Schema.String,
+        cause: Schema.optional(Schema.Defect()),
+    }) {
+        get message() {
+            return this.detail;
+        }
+    }
+    /** Internal: signals "lock is held, retry later". Never leaks to callers. */
+    class NotAcquired extends Schema.TaggedError()("NotAcquired", {}) {
+    }
+    // ---------------------------------------------------------------------------
+    // Timing defaults
+    // ---------------------------------------------------------------------------
+    const DEFAULT_STALE_MS = 60_000;
+    const DEFAULT_TIMEOUT_MS = 5 * 60_000;
+    const BASE_DELAY_MS = 100;
+    const MAX_DELAY_MS = 2_000;
+    const retrySchedule = (timeoutMs) => Schedule.min([
+        Schedule.exponential(BASE_DELAY_MS, 1.7),
+        Schedule.spaced(Math.min(MAX_DELAY_MS, Math.max(BASE_DELAY_MS, Math.floor(timeoutMs / 10)))),
+    ]).pipe(Schedule.jittered, Schedule.while((meta) => meta.elapsed < timeoutMs));
+    // ---------------------------------------------------------------------------
+    // Lock metadata schema
+    // ---------------------------------------------------------------------------
+    const LockMetaJson = Schema.fromJsonString(Schema.Struct({
+        token: Schema.String,
+        pid: Schema.Number,
+        hostname: Schema.String,
+        createdAt: Schema.String,
+    }));
+    const decodeMeta = Schema.decodeUnknownSync(LockMetaJson);
+    const encodeMeta = Schema.encodeSync(LockMetaJson);
+    class Service extends Context.Service()("EffectFlock") {
+    }
+    EffectFlock.Service = Service;
+    // ---------------------------------------------------------------------------
+    // Layer
+    // ---------------------------------------------------------------------------
+    function wall() {
+        return performance.timeOrigin + performance.now();
+    }
+    const mtimeMs = (info) => Option.getOrElse(info.mtime, () => new Date(0)).getTime();
+    const isPathGone = (e) => e.reason._tag === "NotFound" || e.reason._tag === "Unknown";
+    const layer = Layer.effect(Service, Effect.gen(function* () {
+        const global = yield* Global.Service;
+        const fs = yield* FSUtil.Service;
+        const lockRoot = path.join(global.state, "locks");
+        const hostname = os.hostname();
+        const ensuredDirs = new Set();
+        // -- helpers (close over fs) --
+        const safeStat = (file) => fs.stat(file).pipe(Effect.catchIf(isPathGone, () => Effect.void), Effect.orDie);
+        const forceRemove = (target) => fs.remove(target, { recursive: true }).pipe(Effect.ignore);
+        /** Atomic mkdir — returns true if created, false if already exists, dies on other errors. */
+        const atomicMkdir = (dir) => fs.makeDirectory(dir, { mode: 0o700 }).pipe(Effect.as(true), Effect.catchIf((e) => e.reason._tag === "AlreadyExists", () => Effect.succeed(false)), Effect.orDie);
+        /** Write with exclusive create — compromised error if file already exists. */
+        const exclusiveWrite = (filePath, content, lockDir, detail) => fs.writeFileString(filePath, content, { flag: "wx" }).pipe(Effect.catch(() => Effect.gen(function* () {
+            yield* forceRemove(lockDir);
+            return yield* new LockCompromisedError({ detail });
+        })));
+        const cleanStaleBreaker = Effect.fnUntraced(function* (breakerPath, staleMs) {
+            const bs = yield* safeStat(breakerPath);
+            if (bs && wall() - mtimeMs(bs) > staleMs)
+                yield* forceRemove(breakerPath);
+            return false;
+        });
+        const ensureDir = Effect.fnUntraced(function* (dir) {
+            if (ensuredDirs.has(dir))
+                return;
+            yield* fs.makeDirectory(dir, { recursive: true }).pipe(Effect.orDie);
+            ensuredDirs.add(dir);
+        });
+        const isStale = Effect.fnUntraced(function* (lockDir, heartbeatPath, metaPath, staleMs) {
+            const now = wall();
+            const hb = yield* safeStat(heartbeatPath);
+            if (hb)
+                return now - mtimeMs(hb) > staleMs;
+            const meta = yield* safeStat(metaPath);
+            if (meta)
+                return now - mtimeMs(meta) > staleMs;
+            const dir = yield* safeStat(lockDir);
+            if (!dir)
+                return false;
+            return now - mtimeMs(dir) > staleMs;
+        });
+        const tryAcquireLockDir = (lockDir, key, staleMs) => Effect.gen(function* () {
+            const token = randomUUID();
+            const metaPath = path.join(lockDir, "meta.json");
+            const heartbeatPath = path.join(lockDir, "heartbeat");
+            // Atomic mkdir — the POSIX lock primitive
+            const created = yield* atomicMkdir(lockDir);
+            if (!created) {
+                if (!(yield* isStale(lockDir, heartbeatPath, metaPath, staleMs)))
+                    return yield* new NotAcquired();
+                // Stale — race for breaker ownership
+                const breakerPath = lockDir + ".breaker";
+                const claimed = yield* fs.makeDirectory(breakerPath, { mode: 0o700 }).pipe(Effect.as(true), Effect.catchIf((e) => e.reason._tag === "AlreadyExists", () => cleanStaleBreaker(breakerPath, staleMs)), Effect.catchIf(isPathGone, () => Effect.succeed(false)), Effect.orDie);
+                if (!claimed)
+                    return yield* new NotAcquired();
+                // We own the breaker — double-check staleness, nuke, recreate
+                const recreated = yield* Effect.gen(function* () {
+                    if (!(yield* isStale(lockDir, heartbeatPath, metaPath, staleMs)))
+                        return false;
+                    yield* forceRemove(lockDir);
+                    return yield* atomicMkdir(lockDir);
+                }).pipe(Effect.ensuring(forceRemove(breakerPath)));
+                if (!recreated)
+                    return yield* new NotAcquired();
+            }
+            // We own the lock dir — write heartbeat + meta with exclusive create
+            yield* exclusiveWrite(heartbeatPath, "", lockDir, "heartbeat already existed");
+            const metaJson = encodeMeta({ token, pid: process.pid, hostname, createdAt: new Date().toISOString() });
+            yield* exclusiveWrite(metaPath, metaJson, lockDir, "meta.json already existed");
+            return { token, metaPath, heartbeatPath, lockDir };
+        }).pipe(Effect.withSpan("EffectFlock.tryAcquire", {
+            attributes: { key },
+        }));
+        // -- retry wrapper (preserves Handle type) --
+        const acquireHandle = (lockfile, key, options) => tryAcquireLockDir(lockfile, key, options.staleMs).pipe(Effect.retry({
+            while: (err) => err._tag === "NotAcquired",
+            schedule: retrySchedule(options.timeoutMs),
+        }), Effect.catchTag("NotAcquired", () => Effect.fail(new LockTimeoutError({ key }))), Effect.timeoutOrElse({
+            duration: options.timeoutMs,
+            orElse: () => Effect.fail(new LockTimeoutError({ key })),
+        }));
+        // -- release --
+        const release = (handle) => Effect.gen(function* () {
+            const raw = yield* fs.readFileString(handle.metaPath).pipe(Effect.catch((err) => {
+                if (isPathGone(err))
+                    return Effect.die(new ReleaseError({ detail: "metadata missing" }));
+                return Effect.die(err);
+            }));
+            const parsed = yield* Effect.try({
+                try: () => decodeMeta(raw),
+                catch: (cause) => new ReleaseError({ detail: "metadata invalid", cause }),
+            }).pipe(Effect.orDie);
+            if (parsed.token !== handle.token)
+                return yield* Effect.die(new ReleaseError({ detail: "token mismatch" }));
+            yield* forceRemove(handle.lockDir);
+        });
+        // -- build service --
+        const acquire = Effect.fn("EffectFlock.acquire")(function* (key, dir, options = {}) {
+            const lockDir = dir ?? lockRoot;
+            const staleMs = options.staleMs ?? DEFAULT_STALE_MS;
+            const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+            yield* ensureDir(lockDir);
+            const lockfile = path.join(lockDir, Hash.fast(key) + ".lock");
+            // acquireRelease: acquire is uninterruptible, release is guaranteed
+            const handle = yield* Effect.acquireRelease(acquireHandle(lockfile, key, { staleMs, timeoutMs }), (handle) => release(handle));
+            // Heartbeat fiber — scoped, so it's interrupted before release runs
+            yield* Effect.suspend(() => {
+                const now = new Date();
+                return fs.utimes(handle.heartbeatPath, now, now);
+            }).pipe(Effect.ignore, Effect.repeat(Schedule.spaced(Math.max(100, Math.floor(staleMs / 3)))), Effect.forkScoped);
+        });
+        const withLock = Function.dual((args) => Effect.isEffect(args[0]), (body, key, dir) => Effect.scoped(Effect.gen(function* () {
+            yield* acquire(key, dir);
+            return yield* body;
+        })));
+        return Service.of({ acquire, withLock });
+    }));
+    EffectFlock.node = makeGlobalNode({ service: Service, layer: layer, deps: [Global.node, FSUtil.node] });
+})(EffectFlock || (EffectFlock = {}));

package/dist/encode.d.ts ADDED Viewed

@@ -0,0 +1,4 @@
+export declare function base64Encode(value: string): string;
+export declare function base64Decode(value: string): string;
+export declare function checksum(content: string): string | undefined;
+export declare function sampledChecksum(content: string, limit?: number): string | undefined;

package/dist/encode.js ADDED Viewed

@@ -0,0 +1,38 @@
+export function base64Encode(value) {
+    const bytes = new TextEncoder().encode(value);
+    const binary = Array.from(bytes, (byte) => String.fromCharCode(byte)).join("");
+    return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+}
+export function base64Decode(value) {
+    const binary = atob(value.replace(/-/g, "+").replace(/_/g, "/"));
+    return new TextDecoder().decode(Uint8Array.from(binary, (character) => character.charCodeAt(0)));
+}
+export function checksum(content) {
+    if (!content)
+        return;
+    let hash = 0x811c9dc5;
+    for (let index = 0; index < content.length; index++) {
+        hash ^= content.charCodeAt(index);
+        hash = Math.imul(hash, 0x01000193);
+    }
+    return (hash >>> 0).toString(36);
+}
+export function sampledChecksum(content, limit = 500_000) {
+    if (!content)
+        return;
+    if (content.length <= limit)
+        return checksum(content);
+    const size = 4096;
+    return `${content.length}:${[
+        0,
+        Math.floor(content.length * 0.25),
+        Math.floor(content.length * 0.5),
+        Math.floor(content.length * 0.75),
+        content.length - size,
+    ]
+        .map((point) => {
+        const start = Math.max(0, Math.min(content.length - size, point - Math.floor(size / 2)));
+        return checksum(content.slice(start, start + size)) ?? "";
+    })
+        .join(":")}`;
+}

package/dist/encode.test.d.ts ADDED Viewed

	@@ -0,0 +1 @@
1	+ export {};

package/dist/encode.test.js ADDED Viewed

@@ -0,0 +1,23 @@
+import { describe, expect, test } from "bun:test";
+import { base64Decode, base64Encode, checksum, sampledChecksum } from "./encode.js";
+describe("frontend encoding", () => {
+    test("uses unpadded URL-safe UTF-8 base64", () => {
+        expect(base64Encode("hello")).toBe("aGVsbG8");
+        expect(base64Encode("✓ à la mode")).toBe("4pyTIMOgIGxhIG1vZGU");
+        expect(base64Decode("4pyTIMOgIGxhIG1vZGU")).toBe("✓ à la mode");
+        expect(base64Decode("dXNlcjpwYXNz")).toBe("user:pass");
+    });
+    test("rejects invalid base64", () => {
+        expect(() => base64Decode("%%%")).toThrow();
+    });
+    test("keeps stable FNV checksums", () => {
+        expect(checksum("")).toBeUndefined();
+        expect(checksum("hello")).toBe("m3bicr");
+        expect(checksum("✓ à la mode")).toBe("jmczk0");
+    });
+    test("samples large values without changing the size boundary", () => {
+        const value = "abcdef".repeat(100);
+        expect(sampledChecksum(value, value.length)).toBe(checksum(value));
+        expect(sampledChecksum(value, value.length - 1)).toBe("600:1isj1k5:1isj1k5:1isj1k5:1isj1k5:1isj1k5");
+    });
+});