@opencode-ai/core 0.0.0-next-17428 → 0.0.0-next-17444

package/dist/types/shell/parser-wasm.bun.d.ts

@@ -0,0 +1,5 @@
+export declare const shellParserWasm: {
+    runtime: any;
+    bash: any;
+    powershell: any;
+};

package/dist/types/shell/parser-wasm.node.d.ts

@@ -0,0 +1,5 @@
+export declare const shellParserWasm: {
+    runtime: string;
+    bash: string;
+    powershell: string;
+};

package/dist/types/shell/parser-wasm.workerd.d.ts

@@ -0,0 +1,5 @@
+export declare const shellParserWasm: {
+    runtime: string;
+    bash: string;
+    powershell: string;
+};

package/dist/types/util/encode.d.ts

@@ -1,5 +1,4 @@
 export declare function base64Encode(value: string): string;
 export declare function base64Decode(value: string): string;
-export declare function hash(content: string, algorithm?: string): Promise<string>;
 export declare function checksum(content: string): string | undefined;
 export declare function sampledChecksum(content: string, limit?: number): string | undefined;

package/dist/types/v1/config/migrate.d.ts

@@ -17,6 +17,7 @@ export declare function migrate(info: typeof ConfigV1.Info.Type): {
         readonly resource: string;
         readonly effect: "allow" | "deny" | "ask";
     }[] | undefined;
+    readonly share?: "auto" | "disabled" | "manual" | undefined;
     readonly commands?: {
         readonly [x: string]: {
             readonly template: string;
@@ -221,7 +222,6 @@ export declare function migrate(info: typeof ConfigV1.Info.Type): {
     readonly $schema?: string | undefined;
     readonly default_agent?: string | undefined;
     readonly autoupdate?: boolean | "notify" | undefined;
-    readonly share?: "auto" | "disabled" | "manual" | undefined;
     readonly enterprise?: {
         readonly url?: string | undefined;
     } | undefined;

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

@@ -0,0 +1,9 @@
+export * as WorktreeDirectory from "./directory.js";
+import { Effect, Schema } from "effect";
+import { FSUtil } from "@opencode-ai/util/fs-util";
+declare const DirectoryUnavailableError_base: Schema.Class<DirectoryUnavailableError, Schema.TaggedStruct<"Worktree.DirectoryUnavailableError", {
+    readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+}>, import("effect/Cause").YieldableError>;
+export declare class DirectoryUnavailableError extends DirectoryUnavailableError_base {
+}
+export declare const canonical: (fs: FSUtil.Interface, input: string & import("effect/Brand").Brand<"AbsolutePath">) => Effect.Effect<string & import("effect/Brand").Brand<"AbsolutePath">, DirectoryUnavailableError, never>;

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

@@ -0,0 +1,22 @@
+export * as WorktreeGit from "./git.js";
+import { Effect } from "effect";
+import { FSUtil } from "@opencode-ai/util/fs-util";
+import { Git } from "../git.js";
+import { DirectoryUnavailableError } from "./directory.js";
+export declare const make: Effect.Effect<{
+    id: string & import("effect/Brand").Brand<"Worktree.StrategyID">;
+    create: (input: {
+        sourceDirectory: import("@opencode-ai/schema/schema").AbsolutePath;
+        directory: import("@opencode-ai/schema/schema").AbsolutePath;
+    }) => Effect.Effect<{
+        directory: string & import("effect/Brand").Brand<"AbsolutePath">;
+    }, Git.WorktreeError | DirectoryUnavailableError, never>;
+    remove: (input: {
+        directory: import("@opencode-ai/schema/schema").AbsolutePath;
+        force: boolean;
+    }) => Effect.Effect<undefined, Git.WorktreeError | DirectoryUnavailableError, never>;
+    list: (directory: string & import("effect/Brand").Brand<"AbsolutePath">) => Effect.Effect<{
+        readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
+        readonly type: "worktree" | "root";
+    }[], Git.WorktreeError | DirectoryUnavailableError, never>;
+}, never, FSUtil.Service | Git.Service>;

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.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
+        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.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
+        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.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
+        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.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
+        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

@@ -1,4 +1,4 @@
-import"../chunks/wellknown-rvfvac9x.js";
+import"../chunks/catalog-rvfvac9x.js";
 
 // src/util/array.ts
 function findLast(items, predicate) {

package/dist/util/binary.js

@@ -1,4 +1,4 @@
-import"../chunks/wellknown-rvfvac9x.js";
+import"../chunks/catalog-rvfvac9x.js";
 
 // src/util/binary.ts
 var Binary;

package/dist/util/encode.js

@@ -1,4 +1,4 @@
-import"../chunks/wellknown-rvfvac9x.js";
+import"../chunks/catalog-rvfvac9x.js";
 
 // src/util/encode.ts
 function base64Encode(value) {
@@ -11,23 +11,15 @@ function base64Decode(value) {
   const bytes = Uint8Array.from(binary, (c) => c.charCodeAt(0));
   return new TextDecoder().decode(bytes);
 }
-async function hash(content, algorithm = "SHA-256") {
-  const encoder = new TextEncoder;
-  const data = encoder.encode(content);
-  const hashBuffer = await crypto.subtle.digest(algorithm, data);
-  const hashArray = Array.from(new Uint8Array(hashBuffer));
-  const hashHex = hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
-  return hashHex;
-}
 function checksum(content) {
   if (!content)
     return;
-  let hash2 = 2166136261;
+  let hash = 2166136261;
   for (let i = 0;i < content.length; i++) {
-    hash2 ^= content.charCodeAt(i);
-    hash2 = Math.imul(hash2, 16777619);
+    hash ^= content.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
   }
-  return (hash2 >>> 0).toString(36);
+  return (hash >>> 0).toString(36);
 }
 function sampledChecksum(content, limit = 500000) {
   if (!content)
@@ -50,7 +42,6 @@ function sampledChecksum(content, limit = 500000) {
 }
 export {
   sampledChecksum,
-  hash,
   checksum,
   base64Encode,
   base64Decode

package/dist/util/error.js

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

package/dist/util/identifier.js

@@ -1,4 +1,4 @@
-import"../chunks/wellknown-rvfvac9x.js";
+import"../chunks/catalog-rvfvac9x.js";
 
 // src/util/identifier.ts
 import * as Identifier from "@opencode-ai/schema/identifier";

package/dist/util/iife.js

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

package/dist/util/lazy.js

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

package/dist/util/path.js

@@ -1,4 +1,4 @@
-import"../chunks/wellknown-rvfvac9x.js";
+import"../chunks/catalog-rvfvac9x.js";
 
 // src/util/path.ts
 function getFilename(path) {

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

@@ -1,4 +1,4 @@
-import"../chunks/wellknown-rvfvac9x.js";
+import"../chunks/catalog-rvfvac9x.js";
 
 // src/util/process-lock-ffi.bun.ts
 import { dlopen, read } from "bun:ffi";

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

@@ -1,4 +1,4 @@
-import"../chunks/wellknown-rvfvac9x.js";
+import"../chunks/catalog-rvfvac9x.js";
 
 // src/util/process-lock-ffi.node.ts
 import { dlopen, getInt32 } from "node:ffi";

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

@@ -1,4 +1,4 @@
-import"../chunks/wellknown-rvfvac9x.js";
+import"../chunks/catalog-rvfvac9x.js";
 
 // src/util/process-lock-ffi.workerd.ts
 var unavailable = (_fd) => {

package/dist/util/process-lock.js

@@ -1,4 +1,4 @@
-import"../chunks/wellknown-rvfvac9x.js";
+import"../chunks/catalog-rvfvac9x.js";
 
 // src/util/process-lock.ts
 import { lockDarwin, lockLinux } from "#process-lock-ffi";

package/dist/util/retry.js

@@ -1,4 +1,4 @@
-import"../chunks/wellknown-rvfvac9x.js";
+import"../chunks/catalog-rvfvac9x.js";
 
 // src/util/retry.ts
 var TRANSIENT_MESSAGES = [

package/dist/util/slug.js

@@ -1,7 +1,7 @@
 import {
   Slug
-} from "../chunks/wellknown-df3v2q6j.js";
-import"../chunks/wellknown-rvfvac9x.js";
+} from "../chunks/catalog-df3v2q6j.js";
+import"../chunks/catalog-rvfvac9x.js";
 export {
   Slug
 };

package/dist/util/token.js

@@ -1,8 +1,8 @@
 import {
   estimate,
   exports_token
-} from "../chunks/wellknown-v972xay6.js";
-import"../chunks/wellknown-rvfvac9x.js";
+} from "../chunks/catalog-v972xay6.js";
+import"../chunks/catalog-rvfvac9x.js";
 export {
   estimate,
   exports_token as Token

package/dist/util/which.js

@@ -1,7 +1,7 @@
 import {
   which
-} from "../chunks/wellknown-g7k9te92.js";
-import"../chunks/wellknown-rvfvac9x.js";
+} from "../chunks/catalog-g7k9te92.js";
+import"../chunks/catalog-rvfvac9x.js";
 export {
   which
 };