@opencode-ai/core 0.0.0-dev-17471

package/dist/types/worktree/sql.d.ts

@@ -0,0 +1,71 @@
+export declare const WorktreeTable: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    name: "worktree";
+    schema: undefined;
+    columns: {
+        project_id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "worktree";
+            dataType: "string";
+            data: string & import("effect/Brand").Brand<"Project.ID">;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        directory: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "worktree";
+            dataType: "custom";
+            data: string & import("effect/Brand").Brand<"AbsolutePath">;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        strategy: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "worktree";
+            dataType: "string";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        time_created: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "worktree";
+            dataType: "number int53";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: true;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+    };
+    dialect: "sqlite";
+}>;

package/dist/types/worktree.d.ts

@@ -0,0 +1,310 @@
+export * as Worktree from "./worktree.js";
+import { Context, Effect, Schema } from "effect";
+import { AbsolutePath } from "./schema.js";
+import { Git } from "./git.js";
+import { ProjectSchema } from "./project/schema.js";
+import { Location } from "./location.js";
+import { DirectoryUnavailableError } from "./worktree/directory.js";
+export { DirectoryUnavailableError } from "./worktree/directory.js";
+export declare const StrategyID: Schema.brand<Schema.Trim, "Worktree.StrategyID">;
+export type StrategyID = typeof StrategyID.Type;
+export declare const CreateInput: Schema.Struct<{
+    readonly projectID: Schema.brand<Schema.String, "Project.ID"> & {
+        global: string & import("effect/Brand").Brand<"Project.ID">;
+    };
+    readonly strategy: Schema.brand<Schema.Trim, "Worktree.StrategyID">;
+    readonly from: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "AbsolutePath">>>, Schema.optionalKey<Schema.brand<Schema.String, "AbsolutePath">>, never, never>;
+    readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+    readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+}>;
+export type CreateInput = typeof CreateInput.Type;
+export declare const RemoveInput: Schema.Struct<{
+    readonly projectID: Schema.brand<Schema.String, "Project.ID"> & {
+        global: string & import("effect/Brand").Brand<"Project.ID">;
+    };
+    readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+    readonly force: Schema.Boolean;
+}>;
+export type RemoveInput = typeof RemoveInput.Type;
+export declare const RefreshInput: Schema.Struct<{
+    readonly projectID: Schema.brand<Schema.String, "Project.ID"> & {
+        global: string & import("effect/Brand").Brand<"Project.ID">;
+    };
+}>;
+export type RefreshInput = typeof RefreshInput.Type;
+export declare const RefreshResult: Schema.Struct<{
+    readonly updated: Schema.$Array<Schema.brand<Schema.String, "AbsolutePath">>;
+    readonly removed: Schema.$Array<Schema.brand<Schema.String, "AbsolutePath">>;
+}>;
+export type RefreshResult = typeof RefreshResult.Type;
+export declare const Info: Schema.Struct<{
+    readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+}>;
+export type Info = typeof Info.Type;
+export declare const ListInput: Schema.Struct<{
+    readonly projectID: Schema.brand<Schema.String, "Project.ID"> & {
+        global: string & import("effect/Brand").Brand<"Project.ID">;
+    };
+}>;
+export type ListInput = typeof ListInput.Type;
+export declare const List: Schema.$Array<Schema.Struct<{
+    readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+    readonly strategy: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+}>>;
+export type List = typeof List.Type;
+export declare const ListEntry: Schema.Struct<{
+    readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+    readonly type: Schema.Literals<readonly ["root", "worktree"]>;
+}>;
+export type ListEntry = typeof ListEntry.Type;
+declare const SourceDirectoryNotFoundError_base: Schema.Class<SourceDirectoryNotFoundError, Schema.TaggedStruct<"Worktree.SourceDirectoryNotFoundError", {
+    readonly projectID: Schema.brand<Schema.String, "Project.ID"> & {
+        global: string & import("effect/Brand").Brand<"Project.ID">;
+    };
+    readonly directory: Schema.optional<Schema.brand<Schema.String, "AbsolutePath">>;
+}>, import("effect/Cause").YieldableError>;
+export declare class SourceDirectoryNotFoundError extends SourceDirectoryNotFoundError_base {
+}
+declare const DestinationExistsError_base: Schema.Class<DestinationExistsError, Schema.TaggedStruct<"Worktree.DestinationExistsError", {
+    readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+}>, import("effect/Cause").YieldableError>;
+export declare class DestinationExistsError extends DestinationExistsError_base {
+}
+declare const InvalidDirectoryError_base: Schema.Class<InvalidDirectoryError, Schema.TaggedStruct<"Worktree.InvalidDirectoryError", {
+    readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+}>, import("effect/Cause").YieldableError>;
+export declare class InvalidDirectoryError extends InvalidDirectoryError_base {
+}
+declare const StrategyUnavailableError_base: Schema.Class<StrategyUnavailableError, Schema.TaggedStruct<"Worktree.StrategyUnavailableError", {
+    readonly strategy: Schema.brand<Schema.Trim, "Worktree.StrategyID">;
+}>, import("effect/Cause").YieldableError>;
+export declare class StrategyUnavailableError extends StrategyUnavailableError_base {
+}
+declare const DuplicateStrategyError_base: Schema.Class<DuplicateStrategyError, Schema.TaggedStruct<"Worktree.DuplicateStrategyError", {
+    readonly strategy: Schema.brand<Schema.Trim, "Worktree.StrategyID">;
+}>, import("effect/Cause").YieldableError>;
+export declare class DuplicateStrategyError extends DuplicateStrategyError_base {
+}
+export type Error = SourceDirectoryNotFoundError | DestinationExistsError | DirectoryUnavailableError | InvalidDirectoryError | StrategyUnavailableError | Git.WorktreeError;
+export interface Strategy {
+    readonly id: StrategyID;
+    readonly create: (input: {
+        sourceDirectory: AbsolutePath;
+        directory: AbsolutePath;
+    }) => Effect.Effect<Info, Git.WorktreeError | DirectoryUnavailableError>;
+    readonly remove: (input: {
+        directory: AbsolutePath;
+        force: boolean;
+    }) => Effect.Effect<void, Git.WorktreeError | DirectoryUnavailableError>;
+    readonly list: (directory: AbsolutePath) => Effect.Effect<ListEntry[], Git.WorktreeError | DirectoryUnavailableError>;
+}
+export declare const Event: {
+    Updated: Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "Event.ID"> & {
+            create: () => string & import("effect/Brand").Brand<"Event.ID">;
+        };
+        readonly created: Schema.Finite;
+        readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
+        readonly type: Schema.Literal<"worktree.updated">;
+        readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+            readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+            readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+            }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+            }>, never, never>;
+        }>>>, Schema.optionalKey<Schema.Struct<{
+            readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+            readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+            }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+            }>, never, never>;
+        }>>, never, never>;
+        readonly data: Schema.Struct<{
+            readonly projectID: Schema.brand<Schema.String, "Project.ID"> & {
+                global: string & import("effect/Brand").Brand<"Project.ID">;
+            };
+        }>;
+    }> & {
+        type: "worktree.updated";
+        durability: "ephemeral";
+        durable: undefined;
+        data: Schema.Struct<{
+            readonly projectID: Schema.brand<Schema.String, "Project.ID"> & {
+                global: string & import("effect/Brand").Brand<"Project.ID">;
+            };
+        }>;
+    };
+    Resolved: Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "Event.ID"> & {
+            create: () => string & import("effect/Brand").Brand<"Event.ID">;
+        };
+        readonly created: Schema.Finite;
+        readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
+        readonly type: Schema.Literal<"worktree.resolved">;
+        readonly durable: Schema.Struct<{
+            readonly aggregateID: Schema.String;
+            readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
+            readonly version: Schema.decodeTo<Schema.toType<Schema.brand<Schema.Int, "Event.Version">>, Schema.Literal<number>, never, never>;
+        }>;
+        readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+            readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+            readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+            }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+            }>, never, never>;
+        }>>>, Schema.optionalKey<Schema.Struct<{
+            readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+            readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+            }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+            }>, never, never>;
+        }>>, never, never>;
+        readonly data: Schema.Struct<{
+            readonly projectID: Schema.brand<Schema.String, "Project.ID"> & {
+                global: string & import("effect/Brand").Brand<"Project.ID">;
+            };
+            readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+            readonly previous: Schema.brand<Schema.String, "Project.ID"> & {
+                global: string & import("effect/Brand").Brand<"Project.ID">;
+            };
+        }>;
+    }> & {
+        type: "worktree.resolved";
+        durability: "durable";
+        durable: {
+            readonly version: number;
+            readonly aggregate: string;
+        };
+        data: Schema.Struct<{
+            readonly projectID: Schema.brand<Schema.String, "Project.ID"> & {
+                global: string & import("effect/Brand").Brand<"Project.ID">;
+            };
+            readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+            readonly previous: Schema.brand<Schema.String, "Project.ID"> & {
+                global: string & import("effect/Brand").Brand<"Project.ID">;
+            };
+        }>;
+    };
+    Definitions: readonly [Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "Event.ID"> & {
+            create: () => string & import("effect/Brand").Brand<"Event.ID">;
+        };
+        readonly created: Schema.Finite;
+        readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
+        readonly type: Schema.Literal<"worktree.updated">;
+        readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+            readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+            readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+            }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+            }>, never, never>;
+        }>>>, Schema.optionalKey<Schema.Struct<{
+            readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+            readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+            }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+            }>, never, never>;
+        }>>, never, never>;
+        readonly data: Schema.Struct<{
+            readonly projectID: Schema.brand<Schema.String, "Project.ID"> & {
+                global: string & import("effect/Brand").Brand<"Project.ID">;
+            };
+        }>;
+    }> & {
+        type: "worktree.updated";
+        durability: "ephemeral";
+        durable: undefined;
+        data: Schema.Struct<{
+            readonly projectID: Schema.brand<Schema.String, "Project.ID"> & {
+                global: string & import("effect/Brand").Brand<"Project.ID">;
+            };
+        }>;
+    }, Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "Event.ID"> & {
+            create: () => string & import("effect/Brand").Brand<"Event.ID">;
+        };
+        readonly created: Schema.Finite;
+        readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
+        readonly type: Schema.Literal<"worktree.resolved">;
+        readonly durable: Schema.Struct<{
+            readonly aggregateID: Schema.String;
+            readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
+            readonly version: Schema.decodeTo<Schema.toType<Schema.brand<Schema.Int, "Event.Version">>, Schema.Literal<number>, never, never>;
+        }>;
+        readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+            readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+            readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+            }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+            }>, never, never>;
+        }>>>, Schema.optionalKey<Schema.Struct<{
+            readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+            readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+            }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+            }>, never, never>;
+        }>>, never, never>;
+        readonly data: Schema.Struct<{
+            readonly projectID: Schema.brand<Schema.String, "Project.ID"> & {
+                global: string & import("effect/Brand").Brand<"Project.ID">;
+            };
+            readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+            readonly previous: Schema.brand<Schema.String, "Project.ID"> & {
+                global: string & import("effect/Brand").Brand<"Project.ID">;
+            };
+        }>;
+    }> & {
+        type: "worktree.resolved";
+        durability: "durable";
+        durable: {
+            readonly version: number;
+            readonly aggregate: string;
+        };
+        data: Schema.Struct<{
+            readonly projectID: Schema.brand<Schema.String, "Project.ID"> & {
+                global: string & import("effect/Brand").Brand<"Project.ID">;
+            };
+            readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+            readonly previous: Schema.brand<Schema.String, "Project.ID"> & {
+                global: string & import("effect/Brand").Brand<"Project.ID">;
+            };
+        }>;
+    }];
+};
+export interface Interface {
+    readonly register: (strategy: Strategy) => Effect.Effect<void, DuplicateStrategyError>;
+    readonly list: (projectID: ProjectSchema.ID) => Effect.Effect<List>;
+    readonly create: (input: CreateInput) => Effect.Effect<Info, Error>;
+    readonly remove: (input: RemoveInput) => Effect.Effect<void, Error>;
+    readonly refresh: (input: RefreshInput) => Effect.Effect<RefreshResult, Error>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@opencode/v2/Worktree", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const refreshAfterBoot: Effect.Effect<void, never, import("effect/Scope").Scope | Location.Service | Service>;
+export declare const node: import("@opencode-ai/util/effect/layer-node").Node<Service, never, import("@opencode-ai/util/effect/layer-node").Tag<"global">>;
+export declare const refreshNode: import("@opencode-ai/util/effect/layer-node").Node<never, never, import("@opencode-ai/util/effect/layer-node").Tag<"location">>;

package/dist/util/array.js

@@ -0,0 +1,14 @@
+import"../chunks/location-mutation-rvfvac9x.js";
+
+// src/util/array.ts
+function findLast(items, predicate) {
+  for (let i = items.length - 1;i >= 0; i -= 1) {
+    const item = items[i];
+    if (predicate(item, i, items))
+      return item;
+  }
+  return;
+}
+export {
+  findLast
+};

package/dist/util/binary.js

@@ -0,0 +1,43 @@
+import"../chunks/location-mutation-rvfvac9x.js";
+
+// src/util/binary.ts
+var Binary;
+((Binary) => {
+  function search(array, id, compare) {
+    let left = 0;
+    let right = array.length - 1;
+    while (left <= right) {
+      const mid = Math.floor((left + right) / 2);
+      const midId = compare(array[mid]);
+      if (midId === id) {
+        return { found: true, index: mid };
+      } else if (midId < id) {
+        left = mid + 1;
+      } else {
+        right = mid - 1;
+      }
+    }
+    return { found: false, index: left };
+  }
+  Binary.search = search;
+  function insert(array, item, compare) {
+    const id = compare(item);
+    let left = 0;
+    let right = array.length;
+    while (left < right) {
+      const mid = Math.floor((left + right) / 2);
+      const midId = compare(array[mid]);
+      if (midId < id) {
+        left = mid + 1;
+      } else {
+        right = mid;
+      }
+    }
+    array.splice(left, 0, item);
+    return array;
+  }
+  Binary.insert = insert;
+})(Binary ||= {});
+export {
+  Binary
+};

package/dist/util/encode.js

@@ -0,0 +1,48 @@
+import"../chunks/location-mutation-rvfvac9x.js";
+
+// src/util/encode.ts
+function base64Encode(value) {
+  const bytes = new TextEncoder().encode(value);
+  const binary = Array.from(bytes, (b) => String.fromCharCode(b)).join("");
+  return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+}
+function base64Decode(value) {
+  const binary = atob(value.replace(/-/g, "+").replace(/_/g, "/"));
+  const bytes = Uint8Array.from(binary, (c) => c.charCodeAt(0));
+  return new TextDecoder().decode(bytes);
+}
+function checksum(content) {
+  if (!content)
+    return;
+  let hash = 2166136261;
+  for (let i = 0;i < content.length; i++) {
+    hash ^= content.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+  }
+  return (hash >>> 0).toString(36);
+}
+function sampledChecksum(content, limit = 500000) {
+  if (!content)
+    return;
+  if (content.length <= limit)
+    return checksum(content);
+  const size = 4096;
+  const points = [
+    0,
+    Math.floor(content.length * 0.25),
+    Math.floor(content.length * 0.5),
+    Math.floor(content.length * 0.75),
+    content.length - size
+  ];
+  const hashes = points.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(":");
+  return `${content.length}:${hashes}`;
+}
+export {
+  sampledChecksum,
+  checksum,
+  base64Encode,
+  base64Decode
+};

package/dist/util/error.js

@@ -0,0 +1,7 @@
+import {
+  NamedError
+} from "../chunks/location-mutation-hzeg9cfr.js";
+import"../chunks/location-mutation-rvfvac9x.js";
+export {
+  NamedError
+};

package/dist/util/identifier.js

@@ -0,0 +1,7 @@
+import"../chunks/location-mutation-rvfvac9x.js";
+
+// src/util/identifier.ts
+import * as Identifier from "@opencode-ai/schema/identifier";
+export {
+  Identifier
+};

package/dist/util/iife.js

@@ -0,0 +1,7 @@
+import {
+  iife
+} from "../chunks/location-mutation-ehj9csmv.js";
+import"../chunks/location-mutation-rvfvac9x.js";
+export {
+  iife
+};

package/dist/util/lazy.js

@@ -0,0 +1,7 @@
+import {
+  lazy
+} from "../chunks/location-mutation-8w9tzfz1.js";
+import"../chunks/location-mutation-rvfvac9x.js";
+export {
+  lazy
+};

package/dist/util/path.js

@@ -0,0 +1,42 @@
+import"../chunks/location-mutation-rvfvac9x.js";
+
+// src/util/path.ts
+function getFilename(path) {
+  if (!path)
+    return "";
+  const trimmed = path.replace(/[/\\]+$/, "");
+  const parts = trimmed.split(/[/\\]/);
+  return parts[parts.length - 1] ?? "";
+}
+function getDirectory(path) {
+  if (!path)
+    return "";
+  const trimmed = path.replace(/[/\\]+$/, "");
+  const parts = trimmed.split(/[/\\]/);
+  return parts.slice(0, parts.length - 1).join("/") + "/";
+}
+function getFilenameTruncated(path, maxLength = 20) {
+  const filename = getFilename(path);
+  if (filename.length <= maxLength)
+    return filename;
+  const lastDot = filename.lastIndexOf(".");
+  const ext = lastDot <= 0 ? "" : filename.slice(lastDot);
+  const available = maxLength - ext.length - 1;
+  if (available <= 0)
+    return filename.slice(0, maxLength - 1) + "…";
+  return filename.slice(0, available) + "…" + ext;
+}
+function truncateMiddle(text, maxLength = 20) {
+  if (text.length <= maxLength)
+    return text;
+  const available = maxLength - 1;
+  const start = Math.ceil(available / 2);
+  const end = Math.floor(available / 2);
+  return text.slice(0, start) + "…" + text.slice(-end);
+}
+export {
+  truncateMiddle,
+  getFilenameTruncated,
+  getFilename,
+  getDirectory
+};

package/dist/util/process-lock-ffi.bun.js

@@ -0,0 +1,53 @@
+import"../chunks/location-mutation-rvfvac9x.js";
+
+// src/util/process-lock-ffi.bun.ts
+import { dlopen, read } from "bun:ffi";
+import { existsSync } from "node:fs";
+var LOCK_EX = 2;
+var LOCK_NB = 4;
+var DARWIN_EWOULDBLOCK = 35;
+var LINUX_EWOULDBLOCK = 11;
+function lockDarwin(fd) {
+  const library = dlopen("/usr/lib/libSystem.B.dylib", {
+    flock: { args: ["i32", "i32"], returns: "i32" },
+    __error: { args: [], returns: "ptr" }
+  });
+  try {
+    const result = library.symbols.flock(fd, LOCK_EX | LOCK_NB);
+    const code = result === 0 ? 0 : errorCode(library.symbols.__error());
+    if (result === 0)
+      return { acquired: true };
+    if (code === DARWIN_EWOULDBLOCK)
+      return { acquired: false, held: true };
+    return { acquired: false, held: false, code };
+  } finally {
+    library.close();
+  }
+}
+function lockLinux(fd) {
+  const musl = `/lib/libc.musl-${process.arch === "arm64" ? "aarch64" : "x86_64"}.so.1`;
+  const library = dlopen(existsSync(musl) ? musl : "libc.so.6", {
+    flock: { args: ["i32", "i32"], returns: "i32" },
+    __errno_location: { args: [], returns: "ptr" }
+  });
+  try {
+    const result = library.symbols.flock(fd, LOCK_EX | LOCK_NB);
+    const code = result === 0 ? 0 : errorCode(library.symbols.__errno_location());
+    if (result === 0)
+      return { acquired: true };
+    if (code === LINUX_EWOULDBLOCK)
+      return { acquired: false, held: true };
+    return { acquired: false, held: false, code };
+  } finally {
+    library.close();
+  }
+}
+function errorCode(pointer) {
+  if (pointer === null)
+    throw new Error("Failed to read process lock error code");
+  return read.i32(pointer, 0);
+}
+export {
+  lockLinux,
+  lockDarwin
+};