@opencode/core 0.0.0-reserved → 2.0.0

package/dist/types/plugin/service.d.ts

@@ -0,0 +1,32 @@
+export * as Plugin from "./service.js";
+import { Plugin } from "@opencode/schema/plugin";
+import type { Plugin as PluginDefinition } from "@opencode/plugin/effect/plugin";
+import { Context, type Effect, type Exit } from "effect";
+export interface Interface {
+    readonly activate: (plugins: readonly Generation[], failures?: readonly Failure[]) => Effect.Effect<void>;
+    readonly list: () => Effect.Effect<Plugin.Info[]>;
+    readonly close: (exit: Exit.Exit<unknown, unknown>) => Effect.Effect<void>;
+    /** Wait for announced updates and activation to settle; failures remain in the inventory. */
+    readonly awaitActivation: Effect.Effect<void>;
+    /** Keep readiness pending while preparing an update. Run the returned Effect to release it. */
+    readonly hold: () => Effect.Effect<Effect.Effect<void>>;
+}
+export type Failure = Plugin.Info & {
+    readonly state: Extract<Plugin.State, {
+        readonly status: "failed";
+    }>;
+};
+export type Generation = PluginDefinition & {
+    readonly revision: string;
+    readonly source?: Plugin.Source;
+    readonly features?: Plugin.Features;
+};
+declare const Service_base: Context.ServiceClass<Service, "@opencode/Plugin", Interface>;
+export declare class Service extends Service_base {
+}
+/**
+ * Session entry points wait here before reading plugin-provided state such as commands, skills, hooks,
+ * and the model catalog. A cold Location activates its plugins asynchronously, so without the wait an
+ * early request observes an empty registry and admits or fails work the plugins would have shaped.
+ */
+export declare const awaitActivation: Effect.Effect<void, never, Service>;

package/dist/types/plugin/skill.d.ts

@@ -0,0 +1,6 @@
+export * as SkillPlugin from "./skill.js";
+import { Config } from "../config.js";
+export declare const OpencodeContent: string;
+export declare const ReportContent: string;
+export declare const OpencodeDescription = "Use this skill for any question about OpenCode itself, including how OpenCode works, using or configuring it, migrating from V1 to V2, troubleshooting it, developing plugins or integrations, using the OpenCode SDK, clients, server, or API, and contributing to the OpenCode codebase. Also use it for OpenCode agents, commands, skills, tools, permissions, MCP servers, providers, models, themes, keybinds, formatters, the CLI, TUI, desktop app, and web app.";
+export declare const Plugin: import("@opencode/plugin/effect/plugin").Plugin<import("effect/Scope").Scope | Config.Service>;

package/dist/types/plugin/source-directory.d.ts

@@ -0,0 +1,5 @@
+export * as PluginSourceDirectory from "./source-directory.js";
+import { FSUtil } from "@opencode/util/fs-util";
+import { Effect } from "effect";
+export declare const names: readonly ["plugin", "plugins"];
+export declare const discover: (fs: FSUtil.Interface, directory: string) => Effect.Effect<string[], never, never>;

package/dist/types/plugin/supervisor.d.ts

@@ -0,0 +1,10 @@
+export * as PluginSupervisor from "./supervisor.js";
+import { Layer } from "effect";
+import { ConfigPluginSource } from "../config/plugin/source.js";
+import { Plugin } from "../plugin.js";
+import { InstancePlugins } from "./instance.js";
+import { PluginInternal } from "./internal.js";
+import { SdkPlugins } from "./sdk.js";
+import { PluginUpdate } from "./update.js";
+export declare const layer: Layer.Layer<never, never, Plugin.Service | InstancePlugins.Service | SdkPlugins.Service | ConfigPluginSource.Service | PluginUpdate.Service | PluginInternal.Requirements>;
+export declare const node: import("@opencode/util/effect/layer-node").Provider<never, import("../persistent-pty/index.js").UnavailableError, import("@opencode/util/effect/layer-node").Tag<"location">>;

package/dist/types/plugin/update.d.ts

@@ -0,0 +1,20 @@
+export * as PluginUpdate from "./update.js";
+import { Context, Effect, Stream } from "effect";
+import { Npm } from "@opencode/util/npm";
+import { EffectFlock } from "@opencode/util/effect-flock";
+interface Change {
+    readonly target: string;
+    readonly outdated: boolean;
+    readonly updating: boolean;
+}
+export interface Interface {
+    readonly check: (target: string, options?: {
+        readonly refresh?: boolean;
+    }) => Effect.Effect<boolean>;
+    readonly update: (target: string) => Effect.Effect<void, Npm.InstallFailedError | EffectFlock.LockError>;
+    readonly changes: () => Stream.Stream<Change>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@opencode/PluginUpdate", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const node: import("@opencode/util/effect/layer-node").Provider<Service, never, import("@opencode/util/effect/layer-node").Tag<"global">>;

package/dist/types/plugin/variant.d.ts

@@ -0,0 +1,10 @@
+export * as VariantPlugin from "./variant.js";
+import { Model } from "@opencode/schema/model";
+export declare const Plugin: import("@opencode/plugin/effect/plugin").Plugin<import("effect/Scope").Scope>;
+export declare function generate(model: {
+    readonly id: string;
+    readonly modelID?: string;
+    readonly package?: string;
+}, provider?: {
+    readonly package: string;
+}): NonNullable<Model.Info["variants"]>;

package/dist/types/plugin/vcs/git.d.ts

@@ -0,0 +1,4 @@
+export * as VcsGitPlugin from "./git.js";
+import { AppProcess } from "@opencode/util/process";
+import { Location } from "../../location.js";
+export declare const Plugin: import("@opencode/plugin/effect/plugin").Plugin<import("effect/Scope").Scope | AppProcess.Service | Location.Service>;

package/dist/types/plugin/vcs/hg.d.ts

@@ -0,0 +1,5 @@
+export * as VcsHgPlugin from "./hg.js";
+import { FSUtil } from "@opencode/util/fs-util";
+import { AppProcess } from "@opencode/util/process";
+import { Location } from "../../location.js";
+export declare const Plugin: import("@opencode/plugin/effect/plugin").Plugin<import("effect/Scope").Scope | FSUtil.Service | AppProcess.Service | Location.Service>;

package/dist/types/plugin/warming.d.ts

@@ -0,0 +1,4 @@
+export * as WarmingPlugin from "./warming.js";
+import { Scope } from "effect";
+import { Config } from "../config.js";
+export declare const Plugin: import("@opencode/plugin/effect/plugin").Plugin<Scope.Scope | Config.Service>;

package/dist/types/plugin/websearch/exa.d.ts

@@ -0,0 +1,5 @@
+export * as WebSearchExa from "./exa.js";
+import { Scope } from "effect";
+import { HttpClient } from "effect/unstable/http";
+export declare const endpoint = "https://mcp.exa.ai/mcp";
+export declare const Plugin: import("@opencode/plugin/effect/plugin").Plugin<Scope.Scope | HttpClient.HttpClient>;

package/dist/types/plugin/websearch/firecrawl.d.ts

@@ -0,0 +1,5 @@
+export * as WebSearchFirecrawl from "./firecrawl.js";
+import { Scope } from "effect";
+import { HttpClient } from "effect/unstable/http";
+export declare const endpoint = "https://mcp.firecrawl.dev/v2/mcp";
+export declare const Plugin: import("@opencode/plugin/effect/plugin").Plugin<Scope.Scope | HttpClient.HttpClient>;

package/dist/types/plugin/websearch/index.d.ts

@@ -0,0 +1 @@
+export declare const WebSearchPlugins: readonly [import("@opencode/plugin/effect/plugin").Plugin<import("effect/Scope").Scope | import("effect/unstable/http/HttpClient").HttpClient>, import("@opencode/plugin/effect/plugin").Plugin<import("effect/Scope").Scope | import("effect/unstable/http/HttpClient").HttpClient>, import("@opencode/plugin/effect/plugin").Plugin<import("effect/Scope").Scope | import("effect/unstable/http/HttpClient").HttpClient>, import("@opencode/plugin/effect/plugin").Plugin<import("effect/Scope").Scope | import("effect/unstable/http/HttpClient").HttpClient>];

package/dist/types/plugin/websearch/mcp.d.ts

@@ -0,0 +1,9 @@
+export * as WebSearchMcp from "./mcp.js";
+import { Effect, Schema } from "effect";
+import { HttpClient } from "effect/unstable/http";
+export declare const MAX_RESPONSE_BYTES: number;
+export declare const parseResponse: <F extends Schema.Struct.Fields>(body: string, result: Schema.Struct<F>) => Effect.Effect<Schema.Struct.View<F, "Type", Schema.Struct.TypeOptionalKeys<F>, Schema.Struct.TypeMutableKeys<F>> | undefined, Schema.SchemaError, Schema.Struct.DecodingServices<F>>;
+export declare const call: <F extends Schema.Struct.Fields, R extends Schema.Struct.Fields>(http: HttpClient.HttpClient, url: string, tool: string, schema: {
+    readonly input: Schema.Struct<F>;
+    readonly output: Schema.Struct<R>;
+}, value: Schema.Struct.Type<F>, headers?: Record<string, string>) => Effect.Effect<Schema.Struct.View<R, "Type", Schema.Struct.TypeOptionalKeys<R>, Schema.Struct.TypeMutableKeys<R>> | undefined, Error | import("effect/unstable/http/HttpClientError").HttpClientError | Schema.SchemaError, Schema.Struct.EncodingServices<F> | Exclude<Schema.Struct.DecodingServices<R>, import("effect/Scope").Scope>>;

package/dist/types/plugin/websearch/parallel.d.ts

@@ -0,0 +1,5 @@
+export * as WebSearchParallel from "./parallel.js";
+import { Scope } from "effect";
+import { HttpClient } from "effect/unstable/http";
+export declare const endpoint = "https://search.parallel.ai/mcp";
+export declare const Plugin: import("@opencode/plugin/effect/plugin").Plugin<Scope.Scope | HttpClient.HttpClient>;

package/dist/types/plugin/websearch/tavily.d.ts

@@ -0,0 +1,5 @@
+export * as WebSearchTavily from "./tavily.js";
+import { Scope } from "effect";
+import { HttpClient } from "effect/unstable/http";
+export declare const endpoint = "https://api.tavily.com/search";
+export declare const Plugin: import("@opencode/plugin/effect/plugin").Plugin<Scope.Scope | HttpClient.HttpClient>;

package/dist/types/plugin.d.ts

@@ -0,0 +1,8 @@
+export * as Plugin from "./plugin.js";
+export { Event, ID, Info, Source, State } from "@opencode/schema/plugin";
+import { Node } from "@opencode/util/effect/app-node";
+import { LayerNode } from "@opencode/util/effect/layer-node";
+import type { PersistentPty } from "./persistent-pty.js";
+import { Service } from "./plugin/service.js";
+export { awaitActivation, type Generation, type Interface, Service } from "./plugin/service.js";
+export declare const node: LayerNode.Provider<Service, PersistentPty.UnavailableError, typeof Node.tags.values.location>;

package/dist/types/project/schema.d.ts

@@ -0,0 +1,247 @@
+export * as ProjectSchema from "./schema.js";
+import { Schema } from "effect";
+export declare const ID: Schema.brand<Schema.String, "Project.ID"> & {
+    global: string & import("effect/Brand").Brand<"Project.ID">;
+};
+export type ID = typeof ID.Type;
+export declare const Current: Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "Project.ID"> & {
+        global: string & import("effect/Brand").Brand<"Project.ID">;
+    };
+    readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+    readonly canonical: Schema.brand<Schema.String, "AbsolutePath">;
+}>;
+export type Current = typeof Current.Type;
+export declare const Info: Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "Project.ID"> & {
+        global: string & import("effect/Brand").Brand<"Project.ID">;
+    };
+    readonly canonical: Schema.brand<Schema.String, "AbsolutePath">;
+    readonly vcs: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly icon: Schema.decodeTo<Schema.optional<Schema.toType<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>;
+        readonly color: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    }>>>, Schema.optionalKey<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>;
+        readonly color: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    }>>, never, never>;
+    readonly commands: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+        readonly start: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    }>>>, Schema.optionalKey<Schema.Struct<{
+        readonly start: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    }>>, never, never>;
+    readonly time: Schema.Struct<{
+        readonly created: Schema.Int;
+        readonly updated: Schema.Int;
+        readonly initialized: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+    }>;
+    readonly sandboxes: Schema.$Array<Schema.String>;
+}>;
+export interface Info extends Schema.Schema.Type<typeof Info> {
+}
+export declare const UpdateInput: Schema.Struct<{
+    readonly projectID: Schema.brand<Schema.String, "Project.ID"> & {
+        global: string & import("effect/Brand").Brand<"Project.ID">;
+    };
+    readonly canonical: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "AbsolutePath">>>, Schema.optionalKey<Schema.brand<Schema.String, "AbsolutePath">>, never, never>;
+    readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly icon: Schema.decodeTo<Schema.optional<Schema.toType<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>;
+        readonly color: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    }>>>, Schema.optionalKey<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>;
+        readonly color: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    }>>, never, never>;
+    readonly commands: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+        readonly start: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    }>>>, Schema.optionalKey<Schema.Struct<{
+        readonly start: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    }>>, never, never>;
+}>;
+export type UpdateInput = typeof UpdateInput.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.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<"project.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 id: Schema.brand<Schema.String, "Project.ID"> & {
+                global: string & import("effect/Brand").Brand<"Project.ID">;
+            };
+            readonly canonical: Schema.brand<Schema.String, "AbsolutePath">;
+            readonly vcs: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+            readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+            readonly icon: Schema.decodeTo<Schema.optional<Schema.toType<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>;
+                readonly color: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+            }>>>, Schema.optionalKey<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>;
+                readonly color: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+            }>>, never, never>;
+            readonly commands: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+                readonly start: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+            }>>>, Schema.optionalKey<Schema.Struct<{
+                readonly start: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+            }>>, never, never>;
+            readonly time: Schema.Struct<{
+                readonly created: Schema.Int;
+                readonly updated: Schema.Int;
+                readonly initialized: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+            }>;
+            readonly sandboxes: Schema.$Array<Schema.String>;
+        }>;
+    }> & {
+        type: "project.updated";
+        durability: "ephemeral";
+        durable: undefined;
+        data: Schema.Struct<{
+            readonly id: Schema.brand<Schema.String, "Project.ID"> & {
+                global: string & import("effect/Brand").Brand<"Project.ID">;
+            };
+            readonly canonical: Schema.brand<Schema.String, "AbsolutePath">;
+            readonly vcs: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+            readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+            readonly icon: Schema.decodeTo<Schema.optional<Schema.toType<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>;
+                readonly color: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+            }>>>, Schema.optionalKey<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>;
+                readonly color: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+            }>>, never, never>;
+            readonly commands: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+                readonly start: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+            }>>>, Schema.optionalKey<Schema.Struct<{
+                readonly start: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+            }>>, never, never>;
+            readonly time: Schema.Struct<{
+                readonly created: Schema.Int;
+                readonly updated: Schema.Int;
+                readonly initialized: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+            }>;
+            readonly sandboxes: Schema.$Array<Schema.String>;
+        }>;
+    };
+    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<"project.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 id: Schema.brand<Schema.String, "Project.ID"> & {
+                global: string & import("effect/Brand").Brand<"Project.ID">;
+            };
+            readonly canonical: Schema.brand<Schema.String, "AbsolutePath">;
+            readonly vcs: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+            readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+            readonly icon: Schema.decodeTo<Schema.optional<Schema.toType<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>;
+                readonly color: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+            }>>>, Schema.optionalKey<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>;
+                readonly color: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+            }>>, never, never>;
+            readonly commands: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+                readonly start: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+            }>>>, Schema.optionalKey<Schema.Struct<{
+                readonly start: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+            }>>, never, never>;
+            readonly time: Schema.Struct<{
+                readonly created: Schema.Int;
+                readonly updated: Schema.Int;
+                readonly initialized: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+            }>;
+            readonly sandboxes: Schema.$Array<Schema.String>;
+        }>;
+    }> & {
+        type: "project.updated";
+        durability: "ephemeral";
+        durable: undefined;
+        data: Schema.Struct<{
+            readonly id: Schema.brand<Schema.String, "Project.ID"> & {
+                global: string & import("effect/Brand").Brand<"Project.ID">;
+            };
+            readonly canonical: Schema.brand<Schema.String, "AbsolutePath">;
+            readonly vcs: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+            readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+            readonly icon: Schema.decodeTo<Schema.optional<Schema.toType<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>;
+                readonly color: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+            }>>>, Schema.optionalKey<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>;
+                readonly color: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+            }>>, never, never>;
+            readonly commands: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+                readonly start: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+            }>>>, Schema.optionalKey<Schema.Struct<{
+                readonly start: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+            }>>, never, never>;
+            readonly time: Schema.Struct<{
+                readonly created: Schema.Int;
+                readonly updated: Schema.Int;
+                readonly initialized: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+            }>;
+            readonly sandboxes: Schema.$Array<Schema.String>;
+        }>;
+    }];
+};
+export declare const Vcs: Schema.Struct<{
+    readonly type: Schema.String;
+    readonly store: Schema.brand<Schema.String, "AbsolutePath">;
+}>;
+export type Vcs = typeof Vcs.Type;