@opencode-ai/schema 0.0.0-next-17403 → 0.0.0-next-17430

package/dist/durable-event-manifest.js

@@ -1,9 +1,9 @@
 export * as DurableEventManifest from "./durable-event-manifest.js";
 import { Event } from "./event.js";
-import { ProjectDirectories } from "./project-directories.js";
+import { Worktree } from "./worktree.js";
 import { SessionEvent } from "./session-event.js";
 export const SessionDurable = {
     definitions: Event.durableMap(SessionEvent.DurableDefinitions),
     schema: SessionEvent.Durable,
 };
-export const Durable = Event.durableMap([...SessionEvent.DurableDefinitions, ProjectDirectories.Event.Resolved]);
+export const Durable = Event.durableMap([...SessionEvent.DurableDefinitions, Worktree.Event.Resolved]);

package/dist/event-manifest.d.ts

@@ -3839,6 +3839,7 @@ export declare const ServerDefinitions: readonly [Schema.Struct<{
         readonly action: Schema.String;
         readonly resources: Schema.$Array<Schema.String>;
         readonly save: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
+        readonly opaque: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, 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 source: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Struct<{
             readonly type: Schema.Literal<"tool">;
@@ -3865,6 +3866,7 @@ export declare const ServerDefinitions: readonly [Schema.Struct<{
         readonly action: Schema.String;
         readonly resources: Schema.$Array<Schema.String>;
         readonly save: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
+        readonly opaque: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, 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 source: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Struct<{
             readonly type: Schema.Literal<"tool">;
@@ -4003,7 +4005,7 @@ export declare const ServerDefinitions: readonly [Schema.Struct<{
     };
     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<"project.directories.updated">;
+    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"> & {
@@ -4029,7 +4031,7 @@ export declare const ServerDefinitions: readonly [Schema.Struct<{
         };
     }>;
 }> & {
-    type: "project.directories.updated";
+    type: "worktree.updated";
     durability: "ephemeral";
     durable: undefined;
     data: Schema.Struct<{
@@ -4043,7 +4045,7 @@ export declare const ServerDefinitions: readonly [Schema.Struct<{
     };
     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<"project.directory.resolved">;
+    readonly type: Schema.Literal<"worktree.resolved">;
     readonly durable: Schema.Struct<{
         readonly aggregateID: Schema.String;
         readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
@@ -4078,7 +4080,7 @@ export declare const ServerDefinitions: readonly [Schema.Struct<{
         };
     }>;
 }> & {
-    type: "project.directory.resolved";
+    type: "worktree.resolved";
     durability: "durable";
     durable: {
         readonly version: number;
@@ -9513,6 +9515,7 @@ export declare const Definitions: readonly [Schema.Struct<{
         readonly action: Schema.String;
         readonly resources: Schema.$Array<Schema.String>;
         readonly save: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
+        readonly opaque: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, 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 source: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Struct<{
             readonly type: Schema.Literal<"tool">;
@@ -9539,6 +9542,7 @@ export declare const Definitions: readonly [Schema.Struct<{
         readonly action: Schema.String;
         readonly resources: Schema.$Array<Schema.String>;
         readonly save: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
+        readonly opaque: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, 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 source: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Struct<{
             readonly type: Schema.Literal<"tool">;
@@ -9677,7 +9681,7 @@ export declare const Definitions: readonly [Schema.Struct<{
     };
     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<"project.directories.updated">;
+    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"> & {
@@ -9703,7 +9707,7 @@ export declare const Definitions: readonly [Schema.Struct<{
         };
     }>;
 }> & {
-    type: "project.directories.updated";
+    type: "worktree.updated";
     durability: "ephemeral";
     durable: undefined;
     data: Schema.Struct<{
@@ -9717,7 +9721,7 @@ export declare const Definitions: readonly [Schema.Struct<{
     };
     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<"project.directory.resolved">;
+    readonly type: Schema.Literal<"worktree.resolved">;
     readonly durable: Schema.Struct<{
         readonly aggregateID: Schema.String;
         readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
@@ -9752,7 +9756,7 @@ export declare const Definitions: readonly [Schema.Struct<{
         };
     }>;
 }> & {
-    type: "project.directory.resolved";
+    type: "worktree.resolved";
     durability: "durable";
     durable: {
         readonly version: number;

package/dist/event-manifest.js

@@ -18,7 +18,7 @@ import { ModelsDev } from "./models-dev.js";
 import { Permission } from "./permission.js";
 import { Plugin } from "./plugin.js";
 import { Project } from "./project.js";
-import { ProjectDirectories } from "./project-directories.js";
+import { Worktree } from "./worktree.js";
 import { Pty } from "./pty.js";
 import { Question } from "./question.js";
 import { Reference } from "./reference.js";
@@ -35,7 +35,7 @@ import { WorktreeEvent } from "./worktree-event.js";
 import { WebSearch } from "./websearch.js";
 const coreDefinitions = Event.inventory(...SessionEvent.Definitions);
 const foundationDefinitions = Event.inventory(...ModelsDev.Event.Definitions, ...Integration.Event.Definitions, ...Catalog.Event.Definitions, ...Agent.Event.Definitions, ...coreDefinitions);
-const featureDefinitions = Event.inventory(...FileSystem.Event.Definitions, ...Reference.Event.Definitions, ...Permission.Event.Definitions, ...Plugin.Event.Definitions, ...ProjectDirectories.Event.Definitions, ...Command.Event.Definitions, ...Config.Event.Definitions, ...Skill.Event.Definitions, ...Pty.Event.Definitions, ...Shell.Event.Definitions, ...Question.Event.Definitions, ...Form.Event.Definitions, ...WebSearch.Event.Definitions);
+const featureDefinitions = Event.inventory(...FileSystem.Event.Definitions, ...Reference.Event.Definitions, ...Permission.Event.Definitions, ...Plugin.Event.Definitions, ...Worktree.Event.Definitions, ...Command.Event.Definitions, ...Config.Event.Definitions, ...Skill.Event.Definitions, ...Pty.Event.Definitions, ...Shell.Event.Definitions, ...Question.Event.Definitions, ...Form.Event.Definitions, ...WebSearch.Event.Definitions);
 export const ServerDefinitions = Event.inventory(...foundationDefinitions, ...featureDefinitions, 
 // Current events the TUI consumes from the public stream.
 ...SessionStatusEvent.Definitions, ...TuiEvent.Definitions, ...InstallationEvent.Definitions, ...VcsEvent.Definitions, McpEvent.StatusChanged, McpEvent.ResourcesChanged);

package/dist/index.d.ts

@@ -16,7 +16,7 @@ export { Money } from "./money.js";
 export { Permission } from "./permission.js";
 export { PermissionSaved } from "./permission-saved.js";
 export { Project } from "./project.js";
-export { ProjectCopy } from "./project-copy.js";
+export { Worktree } from "./worktree.js";
 export { Provider } from "./provider.js";
 export { Reference } from "./reference.js";
 export { WebSearch } from "./websearch.js";

package/dist/index.js

@@ -16,7 +16,7 @@ export { Money } from "./money.js";
 export { Permission } from "./permission.js";
 export { PermissionSaved } from "./permission-saved.js";
 export { Project } from "./project.js";
-export { ProjectCopy } from "./project-copy.js";
+export { Worktree } from "./worktree.js";
 export { Provider } from "./provider.js";
 export { Reference } from "./reference.js";
 export { WebSearch } from "./websearch.js";

package/dist/permission.d.ts

@@ -18,6 +18,7 @@ export declare const Request: Schema.Struct<{
     readonly action: Schema.String;
     readonly resources: Schema.$Array<Schema.String>;
     readonly save: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
+    readonly opaque: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, 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 source: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Struct<{
         readonly type: Schema.Literal<"tool">;
@@ -71,6 +72,7 @@ export declare const Event: {
             readonly action: Schema.String;
             readonly resources: Schema.$Array<Schema.String>;
             readonly save: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
+            readonly opaque: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, 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 source: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Struct<{
                 readonly type: Schema.Literal<"tool">;
@@ -97,6 +99,7 @@ export declare const Event: {
             readonly action: Schema.String;
             readonly resources: Schema.$Array<Schema.String>;
             readonly save: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
+            readonly opaque: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, 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 source: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Struct<{
                 readonly type: Schema.Literal<"tool">;
@@ -197,6 +200,7 @@ export declare const Event: {
             readonly action: Schema.String;
             readonly resources: Schema.$Array<Schema.String>;
             readonly save: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
+            readonly opaque: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, 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 source: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Struct<{
                 readonly type: Schema.Literal<"tool">;
@@ -223,6 +227,7 @@ export declare const Event: {
             readonly action: Schema.String;
             readonly resources: Schema.$Array<Schema.String>;
             readonly save: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
+            readonly opaque: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, 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 source: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Struct<{
                 readonly type: Schema.Literal<"tool">;

package/dist/permission.js

@@ -18,6 +18,7 @@ const RequestFields = {
     action: Schema.String,
     resources: Schema.Array(Schema.String),
     save: Schema.Array(Schema.String).pipe(optional),
+    opaque: Schema.Boolean.pipe(optional),
     metadata: Schema.Record(Schema.String, Schema.Unknown).pipe(optional),
     source: Source.pipe(optional),
 };

package/dist/project.d.ts

@@ -14,24 +14,6 @@ export declare const Current: Schema.Struct<{
 }>;
 export interface Current extends Schema.Schema.Type<typeof Current> {
 }
-export declare const Directory: 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 interface Directory extends Schema.Schema.Type<typeof Directory> {
-}
-export declare const DirectoriesInput: Schema.Struct<{
-    readonly projectID: Schema.brand<Schema.String, "Project.ID"> & {
-        global: string & import("effect/Brand").Brand<"Project.ID">;
-    };
-}>;
-export interface DirectoriesInput extends Schema.Schema.Type<typeof DirectoriesInput> {
-}
-export declare const Directories: 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 Directories = typeof Directories.Type;
 export declare const Icon: Schema.Struct<{
     readonly url: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
     readonly override: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;

package/dist/project.js

@@ -10,14 +10,6 @@ export const Current = Schema.Struct({
     directory: AbsolutePath,
     canonical: AbsolutePath,
 }).annotate({ identifier: "Project.Current" });
-export const Directory = Schema.Struct({
-    directory: AbsolutePath,
-    strategy: optional(Schema.String),
-}).annotate({ identifier: "Project.Directory" });
-export const DirectoriesInput = Schema.Struct({
-    projectID: ID,
-}).annotate({ identifier: "Project.DirectoriesInput" });
-export const Directories = Schema.Array(Directory).annotate({ identifier: "Project.Directories" });
 export const Icon = Schema.Struct({
     url: optional(Schema.String),
     override: optional(Schema.String),

package/dist/worktree.d.ts

@@ -0,0 +1,255 @@
+export * as Worktree from "./worktree.js";
+import { Schema } from "effect";
+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 interface CreateInput extends Schema.Schema.Type<typeof CreateInput> {
+}
+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 interface RemoveInput extends Schema.Schema.Type<typeof RemoveInput> {
+}
+export declare const Info: Schema.Struct<{
+    readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+}>;
+export interface Info extends Schema.Schema.Type<typeof Info> {
+}
+export declare const Directory: 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 interface Directory extends Schema.Schema.Type<typeof Directory> {
+}
+export declare const ListInput: Schema.Struct<{
+    readonly projectID: Schema.brand<Schema.String, "Project.ID"> & {
+        global: string & import("effect/Brand").Brand<"Project.ID">;
+    };
+}>;
+export interface ListInput extends Schema.Schema.Type<typeof ListInput> {
+}
+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 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 declare function adopt(session: {
+    readonly projectID: string;
+    readonly directory: string;
+}, event: {
+    readonly projectID: string;
+    readonly directory: string;
+    readonly previous: string;
+}): {
+    projectID: string;
+    subpath: string | undefined;
+} | undefined;

package/dist/worktree.js

@@ -0,0 +1,61 @@
+export * as Worktree from "./worktree.js";
+import { Schema } from "effect";
+import { durable, ephemeral, inventory } from "./event.js";
+import { ProjectID } from "./project-id.js";
+import { AbsolutePath, optional } from "./schema.js";
+import { Project } from "./project.js";
+export const StrategyID = Schema.Trim.pipe(Schema.check(Schema.isNonEmpty()), Schema.brand("Worktree.StrategyID"));
+export const CreateInput = Schema.Struct({
+    projectID: ProjectID,
+    strategy: StrategyID,
+    from: optional(AbsolutePath),
+    directory: AbsolutePath,
+    name: optional(Schema.String),
+}).annotate({ identifier: "Worktree.CreateInput" });
+export const RemoveInput = Schema.Struct({
+    projectID: ProjectID,
+    directory: AbsolutePath,
+    force: Schema.Boolean,
+}).annotate({ identifier: "Worktree.RemoveInput" });
+export const Info = Schema.Struct({
+    directory: AbsolutePath,
+}).annotate({ identifier: "Worktree.Info" });
+export const Directory = Schema.Struct({
+    directory: AbsolutePath,
+    strategy: optional(Schema.String),
+}).annotate({ identifier: "Worktree.Directory" });
+export const ListInput = Schema.Struct({
+    projectID: ProjectID,
+}).annotate({ identifier: "Worktree.ListInput" });
+export const List = Schema.Array(Directory).annotate({ identifier: "Worktree.List" });
+const Updated = ephemeral({
+    type: "worktree.updated",
+    schema: { projectID: Project.ID },
+});
+const Resolved = durable({
+    type: "worktree.resolved",
+    durable: { aggregate: "projectID", version: 1 },
+    schema: {
+        projectID: Project.ID,
+        directory: AbsolutePath,
+        previous: Project.ID,
+    },
+});
+export const Event = { Updated, Resolved, Definitions: inventory(Updated, Resolved) };
+export function adopt(session, event) {
+    if (session.projectID !== event.previous && session.projectID !== Project.ID.global)
+        return;
+    if (session.projectID === event.projectID)
+        return;
+    const inside = session.directory === event.directory ||
+        session.directory.startsWith(event.directory + "/") ||
+        session.directory.startsWith(event.directory + "\\");
+    if (!inside)
+        return;
+    return {
+        projectID: event.projectID,
+        subpath: session.directory === event.directory
+            ? undefined
+            : session.directory.slice(event.directory.length + 1).replaceAll("\\", "/"),
+    };
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@opencode-ai/schema",
-  "version": "0.0.0-next-17403",
+  "version": "0.0.0-next-17430",
   "type": "module",
   "license": "MIT",
   "repository": {

package/dist/project-copy.d.ts

@@ -1,29 +0,0 @@
-export * as ProjectCopy from "./project-copy.js";
-import { Schema } from "effect";
-export declare const StrategyID: Schema.brand<Schema.Trim, "ProjectCopy.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, "ProjectCopy.StrategyID">;
-    readonly sourceDirectory: Schema.brand<Schema.String, "AbsolutePath">;
-    readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
-    readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-}>;
-export interface CreateInput extends Schema.Schema.Type<typeof CreateInput> {
-}
-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 interface RemoveInput extends Schema.Schema.Type<typeof RemoveInput> {
-}
-export declare const Copy: Schema.Struct<{
-    readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
-}>;
-export interface Copy extends Schema.Schema.Type<typeof Copy> {
-}

package/dist/project-copy.js

@@ -1,21 +0,0 @@
-export * as ProjectCopy from "./project-copy.js";
-import { Schema } from "effect";
-import { optional } from "./schema.js";
-import { ProjectID } from "./project-id.js";
-import { AbsolutePath } from "./schema.js";
-export const StrategyID = Schema.Trim.pipe(Schema.check(Schema.isNonEmpty()), Schema.brand("ProjectCopy.StrategyID"));
-export const CreateInput = Schema.Struct({
-    projectID: ProjectID,
-    strategy: StrategyID,
-    sourceDirectory: AbsolutePath,
-    directory: AbsolutePath,
-    name: optional(Schema.String),
-}).annotate({ identifier: "ProjectCopy.CreateInput" });
-export const RemoveInput = Schema.Struct({
-    projectID: ProjectID,
-    directory: AbsolutePath,
-    force: Schema.Boolean,
-}).annotate({ identifier: "ProjectCopy.RemoveInput" });
-export const Copy = Schema.Struct({
-    directory: AbsolutePath,
-}).annotate({ identifier: "ProjectCopy.Copy" });

package/dist/project-directories.d.ts

@@ -1,215 +0,0 @@
-export * as ProjectDirectories from "./project-directories.js";
-export declare const Event: {
-    Updated: import("effect/Schema").Struct<{
-        readonly id: import("effect/Schema").brand<import("effect/Schema").String, "Event.ID"> & {
-            create: () => string & import("effect/Brand").Brand<"Event.ID">;
-        };
-        readonly created: import("effect/Schema").decodeTo<import("effect/Schema").DateTimeUtc, import("effect/Schema").Finite, never, never>;
-        readonly metadata: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Unknown>>>, import("effect/Schema").optionalKey<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Unknown>>, never, never>;
-        readonly type: import("effect/Schema").Literal<"project.directories.updated">;
-        readonly location: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Struct<{
-            readonly directory: import("effect/Schema").brand<import("effect/Schema").String, "AbsolutePath">;
-            readonly workspaceID: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").brand<import("effect/Schema").String, "Workspace.ID"> & {
-                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
-                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
-            }>>, import("effect/Schema").optionalKey<import("effect/Schema").brand<import("effect/Schema").String, "Workspace.ID"> & {
-                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
-                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
-            }>, never, never>;
-        }>>>, import("effect/Schema").optionalKey<import("effect/Schema").Struct<{
-            readonly directory: import("effect/Schema").brand<import("effect/Schema").String, "AbsolutePath">;
-            readonly workspaceID: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").brand<import("effect/Schema").String, "Workspace.ID"> & {
-                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
-                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
-            }>>, import("effect/Schema").optionalKey<import("effect/Schema").brand<import("effect/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: import("effect/Schema").Struct<{
-            readonly projectID: import("effect/Schema").brand<import("effect/Schema").String, "Project.ID"> & {
-                global: string & import("effect/Brand").Brand<"Project.ID">;
-            };
-        }>;
-    }> & {
-        type: "project.directories.updated";
-        durability: "ephemeral";
-        durable: undefined;
-        data: import("effect/Schema").Struct<{
-            readonly projectID: import("effect/Schema").brand<import("effect/Schema").String, "Project.ID"> & {
-                global: string & import("effect/Brand").Brand<"Project.ID">;
-            };
-        }>;
-    };
-    Resolved: import("effect/Schema").Struct<{
-        readonly id: import("effect/Schema").brand<import("effect/Schema").String, "Event.ID"> & {
-            create: () => string & import("effect/Brand").Brand<"Event.ID">;
-        };
-        readonly created: import("effect/Schema").decodeTo<import("effect/Schema").DateTimeUtc, import("effect/Schema").Finite, never, never>;
-        readonly metadata: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Unknown>>>, import("effect/Schema").optionalKey<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Unknown>>, never, never>;
-        readonly type: import("effect/Schema").Literal<"project.directory.resolved">;
-        readonly durable: import("effect/Schema").Struct<{
-            readonly aggregateID: import("effect/Schema").String;
-            readonly seq: import("effect/Schema").brand<import("effect/Schema").Int, "Event.Seq">;
-            readonly version: import("effect/Schema").decodeTo<import("effect/Schema").toType<import("effect/Schema").brand<import("effect/Schema").Int, "Event.Version">>, import("effect/Schema").Literal<number>, never, never>;
-        }>;
-        readonly location: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Struct<{
-            readonly directory: import("effect/Schema").brand<import("effect/Schema").String, "AbsolutePath">;
-            readonly workspaceID: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").brand<import("effect/Schema").String, "Workspace.ID"> & {
-                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
-                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
-            }>>, import("effect/Schema").optionalKey<import("effect/Schema").brand<import("effect/Schema").String, "Workspace.ID"> & {
-                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
-                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
-            }>, never, never>;
-        }>>>, import("effect/Schema").optionalKey<import("effect/Schema").Struct<{
-            readonly directory: import("effect/Schema").brand<import("effect/Schema").String, "AbsolutePath">;
-            readonly workspaceID: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").brand<import("effect/Schema").String, "Workspace.ID"> & {
-                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
-                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
-            }>>, import("effect/Schema").optionalKey<import("effect/Schema").brand<import("effect/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: import("effect/Schema").Struct<{
-            readonly projectID: import("effect/Schema").brand<import("effect/Schema").String, "Project.ID"> & {
-                global: string & import("effect/Brand").Brand<"Project.ID">;
-            };
-            readonly directory: import("effect/Schema").brand<import("effect/Schema").String, "AbsolutePath">;
-            readonly previous: import("effect/Schema").brand<import("effect/Schema").String, "Project.ID"> & {
-                global: string & import("effect/Brand").Brand<"Project.ID">;
-            };
-        }>;
-    }> & {
-        type: "project.directory.resolved";
-        durability: "durable";
-        durable: {
-            readonly version: number;
-            readonly aggregate: string;
-        };
-        data: import("effect/Schema").Struct<{
-            readonly projectID: import("effect/Schema").brand<import("effect/Schema").String, "Project.ID"> & {
-                global: string & import("effect/Brand").Brand<"Project.ID">;
-            };
-            readonly directory: import("effect/Schema").brand<import("effect/Schema").String, "AbsolutePath">;
-            readonly previous: import("effect/Schema").brand<import("effect/Schema").String, "Project.ID"> & {
-                global: string & import("effect/Brand").Brand<"Project.ID">;
-            };
-        }>;
-    };
-    Definitions: readonly [import("effect/Schema").Struct<{
-        readonly id: import("effect/Schema").brand<import("effect/Schema").String, "Event.ID"> & {
-            create: () => string & import("effect/Brand").Brand<"Event.ID">;
-        };
-        readonly created: import("effect/Schema").decodeTo<import("effect/Schema").DateTimeUtc, import("effect/Schema").Finite, never, never>;
-        readonly metadata: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Unknown>>>, import("effect/Schema").optionalKey<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Unknown>>, never, never>;
-        readonly type: import("effect/Schema").Literal<"project.directories.updated">;
-        readonly location: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Struct<{
-            readonly directory: import("effect/Schema").brand<import("effect/Schema").String, "AbsolutePath">;
-            readonly workspaceID: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").brand<import("effect/Schema").String, "Workspace.ID"> & {
-                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
-                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
-            }>>, import("effect/Schema").optionalKey<import("effect/Schema").brand<import("effect/Schema").String, "Workspace.ID"> & {
-                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
-                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
-            }>, never, never>;
-        }>>>, import("effect/Schema").optionalKey<import("effect/Schema").Struct<{
-            readonly directory: import("effect/Schema").brand<import("effect/Schema").String, "AbsolutePath">;
-            readonly workspaceID: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").brand<import("effect/Schema").String, "Workspace.ID"> & {
-                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
-                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
-            }>>, import("effect/Schema").optionalKey<import("effect/Schema").brand<import("effect/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: import("effect/Schema").Struct<{
-            readonly projectID: import("effect/Schema").brand<import("effect/Schema").String, "Project.ID"> & {
-                global: string & import("effect/Brand").Brand<"Project.ID">;
-            };
-        }>;
-    }> & {
-        type: "project.directories.updated";
-        durability: "ephemeral";
-        durable: undefined;
-        data: import("effect/Schema").Struct<{
-            readonly projectID: import("effect/Schema").brand<import("effect/Schema").String, "Project.ID"> & {
-                global: string & import("effect/Brand").Brand<"Project.ID">;
-            };
-        }>;
-    }, import("effect/Schema").Struct<{
-        readonly id: import("effect/Schema").brand<import("effect/Schema").String, "Event.ID"> & {
-            create: () => string & import("effect/Brand").Brand<"Event.ID">;
-        };
-        readonly created: import("effect/Schema").decodeTo<import("effect/Schema").DateTimeUtc, import("effect/Schema").Finite, never, never>;
-        readonly metadata: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Unknown>>>, import("effect/Schema").optionalKey<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Unknown>>, never, never>;
-        readonly type: import("effect/Schema").Literal<"project.directory.resolved">;
-        readonly durable: import("effect/Schema").Struct<{
-            readonly aggregateID: import("effect/Schema").String;
-            readonly seq: import("effect/Schema").brand<import("effect/Schema").Int, "Event.Seq">;
-            readonly version: import("effect/Schema").decodeTo<import("effect/Schema").toType<import("effect/Schema").brand<import("effect/Schema").Int, "Event.Version">>, import("effect/Schema").Literal<number>, never, never>;
-        }>;
-        readonly location: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Struct<{
-            readonly directory: import("effect/Schema").brand<import("effect/Schema").String, "AbsolutePath">;
-            readonly workspaceID: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").brand<import("effect/Schema").String, "Workspace.ID"> & {
-                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
-                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
-            }>>, import("effect/Schema").optionalKey<import("effect/Schema").brand<import("effect/Schema").String, "Workspace.ID"> & {
-                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
-                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
-            }>, never, never>;
-        }>>>, import("effect/Schema").optionalKey<import("effect/Schema").Struct<{
-            readonly directory: import("effect/Schema").brand<import("effect/Schema").String, "AbsolutePath">;
-            readonly workspaceID: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").brand<import("effect/Schema").String, "Workspace.ID"> & {
-                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
-                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
-            }>>, import("effect/Schema").optionalKey<import("effect/Schema").brand<import("effect/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: import("effect/Schema").Struct<{
-            readonly projectID: import("effect/Schema").brand<import("effect/Schema").String, "Project.ID"> & {
-                global: string & import("effect/Brand").Brand<"Project.ID">;
-            };
-            readonly directory: import("effect/Schema").brand<import("effect/Schema").String, "AbsolutePath">;
-            readonly previous: import("effect/Schema").brand<import("effect/Schema").String, "Project.ID"> & {
-                global: string & import("effect/Brand").Brand<"Project.ID">;
-            };
-        }>;
-    }> & {
-        type: "project.directory.resolved";
-        durability: "durable";
-        durable: {
-            readonly version: number;
-            readonly aggregate: string;
-        };
-        data: import("effect/Schema").Struct<{
-            readonly projectID: import("effect/Schema").brand<import("effect/Schema").String, "Project.ID"> & {
-                global: string & import("effect/Brand").Brand<"Project.ID">;
-            };
-            readonly directory: import("effect/Schema").brand<import("effect/Schema").String, "AbsolutePath">;
-            readonly previous: import("effect/Schema").brand<import("effect/Schema").String, "Project.ID"> & {
-                global: string & import("effect/Brand").Brand<"Project.ID">;
-            };
-        }>;
-    }];
-};
-/**
- * Client-side mirror of the server's `project.directory.resolved` session fold.
- * Returns the ownership update for a cached session, or undefined when the
- * session does not follow the resolution. Plain strings: callers hold
- * generated client types, and the server projection remains authoritative.
- */
-export declare function adopt(session: {
-    readonly projectID: string;
-    readonly directory: string;
-}, event: {
-    readonly projectID: string;
-    readonly directory: string;
-    readonly previous: string;
-}): {
-    projectID: string;
-    subpath: string | undefined;
-} | undefined;

package/dist/project-directories.js

@@ -1,47 +0,0 @@
-export * as ProjectDirectories from "./project-directories.js";
-import { durable, ephemeral, inventory } from "./event.js";
-import { AbsolutePath } from "./schema.js";
-import { Project } from "./project.js";
-const Updated = ephemeral({
-    type: "project.directories.updated",
-    schema: { projectID: Project.ID },
-});
-/**
- * A directory's resolution changed: it now resolves to `projectID` where it
- * previously resolved to `previous` (`global` when the directory had no
- * stable identity yet, e.g. before `git init`). Sessions whose ownership
- * came from the previous resolution follow the new identity by projection.
- */
-const Resolved = durable({
-    type: "project.directory.resolved",
-    durable: { aggregate: "projectID", version: 1 },
-    schema: {
-        projectID: Project.ID,
-        directory: AbsolutePath,
-        previous: Project.ID,
-    },
-});
-export const Event = { Updated, Resolved, Definitions: inventory(Updated, Resolved) };
-/**
- * Client-side mirror of the server's `project.directory.resolved` session fold.
- * Returns the ownership update for a cached session, or undefined when the
- * session does not follow the resolution. Plain strings: callers hold
- * generated client types, and the server projection remains authoritative.
- */
-export function adopt(session, event) {
-    if (session.projectID !== event.previous && session.projectID !== Project.ID.global)
-        return;
-    if (session.projectID === event.projectID)
-        return;
-    const inside = session.directory === event.directory ||
-        session.directory.startsWith(event.directory + "/") ||
-        session.directory.startsWith(event.directory + "\\");
-    if (!inside)
-        return;
-    return {
-        projectID: event.projectID,
-        subpath: session.directory === event.directory
-            ? undefined
-            : session.directory.slice(event.directory.length + 1).replaceAll("\\", "/"),
-    };
-}