@opencode/core 0.0.0-reserved → 2.0.1

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

@@ -0,0 +1,112 @@
+export * as ConfigProviderV1 from "./provider.js";
+import { Schema } from "effect";
+export declare const ModelStatus: Schema.Literals<readonly ["alpha", "beta", "deprecated", "active"]>;
+export declare const Model: Schema.Struct<{
+    readonly id: Schema.optional<Schema.String>;
+    readonly name: Schema.optional<Schema.String>;
+    readonly family: Schema.optional<Schema.String>;
+    readonly release_date: Schema.optional<Schema.String>;
+    readonly attachment: Schema.optional<Schema.Boolean>;
+    readonly reasoning: Schema.optional<Schema.Boolean>;
+    readonly temperature: Schema.optional<Schema.Boolean>;
+    readonly tool_call: Schema.optional<Schema.Boolean>;
+    readonly interleaved: Schema.optional<Schema.Union<readonly [Schema.Boolean, Schema.String, Schema.Struct<{
+        readonly field: Schema.String;
+    }>]>>;
+    readonly cost: Schema.optional<Schema.Struct<{
+        readonly input: Schema.Finite;
+        readonly output: Schema.Finite;
+        readonly cache_read: Schema.optional<Schema.Finite>;
+        readonly cache_write: Schema.optional<Schema.Finite>;
+        readonly context_over_200k: Schema.optional<Schema.Struct<{
+            readonly input: Schema.Finite;
+            readonly output: Schema.Finite;
+            readonly cache_read: Schema.optional<Schema.Finite>;
+            readonly cache_write: Schema.optional<Schema.Finite>;
+        }>>;
+    }>>;
+    readonly limit: Schema.optional<Schema.Struct<{
+        readonly context: Schema.Finite;
+        readonly input: Schema.optional<Schema.Finite>;
+        readonly output: Schema.Finite;
+    }>>;
+    readonly modalities: Schema.optional<Schema.Struct<{
+        readonly input: Schema.optional<Schema.mutable<Schema.$Array<Schema.Literals<readonly ["text", "audio", "image", "video", "pdf"]>>>>;
+        readonly output: Schema.optional<Schema.mutable<Schema.$Array<Schema.Literals<readonly ["text", "audio", "image", "video", "pdf"]>>>>;
+    }>>;
+    readonly experimental: Schema.optional<Schema.Boolean>;
+    readonly status: Schema.optional<Schema.Literals<readonly ["alpha", "beta", "deprecated", "active"]>>;
+    readonly provider: Schema.optional<Schema.Struct<{
+        readonly npm: Schema.optional<Schema.String>;
+        readonly api: Schema.optional<Schema.String>;
+    }>>;
+    readonly options: Schema.optional<Schema.$Record<Schema.String, Schema.Any>>;
+    readonly headers: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
+    readonly variants: Schema.optional<Schema.$Record<Schema.String, Schema.StructWithRest<Schema.Struct<{
+        readonly disabled: Schema.optional<Schema.Boolean>;
+    }>, readonly [Schema.$Record<Schema.String, Schema.Any>]>>>;
+}>;
+export declare const Info: Schema.Struct<{
+    readonly api: Schema.optional<Schema.String>;
+    readonly name: Schema.optional<Schema.String>;
+    readonly env: Schema.optional<Schema.mutable<Schema.$Array<Schema.String>>>;
+    readonly id: Schema.optional<Schema.String>;
+    readonly npm: Schema.optional<Schema.String>;
+    readonly whitelist: Schema.optional<Schema.mutable<Schema.$Array<Schema.String>>>;
+    readonly blacklist: Schema.optional<Schema.mutable<Schema.$Array<Schema.String>>>;
+    readonly options: Schema.optional<Schema.StructWithRest<Schema.Struct<{
+        readonly apiKey: Schema.optional<Schema.String>;
+        readonly baseURL: Schema.optional<Schema.String>;
+        readonly enterpriseUrl: Schema.optional<Schema.String>;
+        readonly setCacheKey: Schema.optional<Schema.Boolean>;
+        readonly timeout: Schema.optional<Schema.Union<readonly [Schema.Int, Schema.Literal<false>]>>;
+        readonly headerTimeout: Schema.optional<Schema.Union<readonly [Schema.Int, Schema.Literal<false>]>>;
+        readonly chunkTimeout: Schema.optional<Schema.Int>;
+    }>, readonly [Schema.$Record<Schema.String, Schema.Any>]>>;
+    readonly models: Schema.optional<Schema.$Record<Schema.String, Schema.Struct<{
+        readonly id: Schema.optional<Schema.String>;
+        readonly name: Schema.optional<Schema.String>;
+        readonly family: Schema.optional<Schema.String>;
+        readonly release_date: Schema.optional<Schema.String>;
+        readonly attachment: Schema.optional<Schema.Boolean>;
+        readonly reasoning: Schema.optional<Schema.Boolean>;
+        readonly temperature: Schema.optional<Schema.Boolean>;
+        readonly tool_call: Schema.optional<Schema.Boolean>;
+        readonly interleaved: Schema.optional<Schema.Union<readonly [Schema.Boolean, Schema.String, Schema.Struct<{
+            readonly field: Schema.String;
+        }>]>>;
+        readonly cost: Schema.optional<Schema.Struct<{
+            readonly input: Schema.Finite;
+            readonly output: Schema.Finite;
+            readonly cache_read: Schema.optional<Schema.Finite>;
+            readonly cache_write: Schema.optional<Schema.Finite>;
+            readonly context_over_200k: Schema.optional<Schema.Struct<{
+                readonly input: Schema.Finite;
+                readonly output: Schema.Finite;
+                readonly cache_read: Schema.optional<Schema.Finite>;
+                readonly cache_write: Schema.optional<Schema.Finite>;
+            }>>;
+        }>>;
+        readonly limit: Schema.optional<Schema.Struct<{
+            readonly context: Schema.Finite;
+            readonly input: Schema.optional<Schema.Finite>;
+            readonly output: Schema.Finite;
+        }>>;
+        readonly modalities: Schema.optional<Schema.Struct<{
+            readonly input: Schema.optional<Schema.mutable<Schema.$Array<Schema.Literals<readonly ["text", "audio", "image", "video", "pdf"]>>>>;
+            readonly output: Schema.optional<Schema.mutable<Schema.$Array<Schema.Literals<readonly ["text", "audio", "image", "video", "pdf"]>>>>;
+        }>>;
+        readonly experimental: Schema.optional<Schema.Boolean>;
+        readonly status: Schema.optional<Schema.Literals<readonly ["alpha", "beta", "deprecated", "active"]>>;
+        readonly provider: Schema.optional<Schema.Struct<{
+            readonly npm: Schema.optional<Schema.String>;
+            readonly api: Schema.optional<Schema.String>;
+        }>>;
+        readonly options: Schema.optional<Schema.$Record<Schema.String, Schema.Any>>;
+        readonly headers: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
+        readonly variants: Schema.optional<Schema.$Record<Schema.String, Schema.StructWithRest<Schema.Struct<{
+            readonly disabled: Schema.optional<Schema.Boolean>;
+        }>, readonly [Schema.$Record<Schema.String, Schema.Any>]>>>;
+    }>>>;
+}>;
+export type Info = Schema.Schema.Type<typeof Info>;

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

@@ -0,0 +1,10 @@
+export * as ConfigServerV1 from "./server.js";
+import { Schema } from "effect";
+export declare const Server: Schema.Struct<{
+    readonly port: Schema.optional<Schema.Int>;
+    readonly hostname: Schema.optional<Schema.String>;
+    readonly mdns: Schema.optional<Schema.Boolean>;
+    readonly mdnsDomain: Schema.optional<Schema.String>;
+    readonly cors: Schema.optional<Schema.mutable<Schema.$Array<Schema.String>>>;
+}>;
+export type Server = Schema.Schema.Type<typeof Server>;

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

@@ -0,0 +1,7 @@
+export * as ConfigSkillsV1 from "./skills.js";
+import { Schema } from "effect";
+export declare const Info: Schema.Struct<{
+    readonly paths: Schema.optional<Schema.$Array<Schema.String>>;
+    readonly urls: Schema.optional<Schema.$Array<Schema.String>>;
+}>;
+export type Info = Schema.Schema.Type<typeof Info>;

package/dist/types/v1/permission.d.ts

@@ -0,0 +1,27 @@
+export * as PermissionV1 from "./permission.js";
+import { Schema } from "effect";
+export * from "@opencode/schema/permission-v1";
+declare const RejectedError_base: Schema.Class<RejectedError, Schema.TaggedStruct<"PermissionRejectedError", {}>, import("effect/Cause").YieldableError>;
+export declare class RejectedError extends RejectedError_base {
+    get message(): string;
+}
+declare const CorrectedError_base: Schema.Class<CorrectedError, Schema.TaggedStruct<"PermissionCorrectedError", {
+    readonly feedback: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class CorrectedError extends CorrectedError_base {
+    get message(): string;
+}
+declare const DeniedError_base: Schema.Class<DeniedError, Schema.TaggedStruct<"PermissionDeniedError", {
+    readonly ruleset: Schema.Any;
+}>, import("effect/Cause").YieldableError>;
+export declare class DeniedError extends DeniedError_base {
+    get message(): string;
+}
+declare const NotFoundError_base: Schema.Class<NotFoundError, Schema.TaggedStruct<"Permission.NotFoundError", {
+    readonly requestID: Schema.brand<Schema.String, "PermissionV1.ID"> & {
+        ascending: (id?: string) => string & import("effect/Brand").Brand<"PermissionV1.ID">;
+    };
+}>, import("effect/Cause").YieldableError>;
+export declare class NotFoundError extends NotFoundError_base {
+}
+export type Error = DeniedError | RejectedError | CorrectedError;

package/dist/types/vcs/patch.d.ts

@@ -0,0 +1,21 @@
+export * as VcsPatch from "./patch.js";
+export declare const PATCH_CONTEXT_LINES = 2147483647;
+export declare const MAX_PATCH_BYTES = 10000000;
+export declare const MAX_TOTAL_PATCH_BYTES = 10000000;
+export interface Patch {
+    readonly text: string;
+    readonly truncated: boolean;
+}
+export declare const emptyPatch: (file: string) => string;
+export declare const addPatch: (file: string, content: string) => string;
+export declare const deletePatch: (file: string, content: string) => string;
+/** Count changed lines in a unified diff, ignoring `+++`/`---` file headers. */
+export declare const countPatch: (patch: string) => {
+    additions: number;
+    deletions: number;
+};
+export declare const fileFromPatchChunk: (chunk: string) => string | undefined;
+/** Split `git diff`-format output into per-file chunks, dropping a trailing partial chunk when truncated. */
+export declare const splitGitPatch: (patch: Patch) => string[];
+/** Map per-file chunks by the file they touch, concatenating chunks for the same file. */
+export declare const chunksByFile: (patch: Patch, fallback: (index: number) => string | undefined) => Map<string, string>;

package/dist/types/vcs.d.ts

@@ -0,0 +1,34 @@
+export * as Vcs from "./vcs.js";
+import { Cause, Context, Effect, Schema } from "effect";
+import type { VcsEditor } from "@opencode/plugin/effect/vcs";
+import { FileDiff } from "@opencode/schema/file-diff";
+import { Base, BranchList, FileStatus, Info, Mode } from "@opencode/schema/vcs";
+import { State } from "./state.js";
+export { Base, BranchList, FileStatus, Info, Mode };
+declare const DiffError_base: Schema.Class<DiffError, Schema.TaggedStruct<"Vcs.DiffError", {
+    readonly message: Schema.String;
+}>, Cause.YieldableError>;
+export declare class DiffError extends DiffError_base {
+}
+export interface DiffOptions {
+    readonly context?: number;
+    readonly base?: string;
+}
+export interface BranchOptions {
+    readonly search?: string;
+    readonly limit?: number;
+}
+export interface Adapter {
+    readonly info: () => Effect.Effect<Info>;
+    readonly base?: () => Effect.Effect<Base | null, DiffError>;
+    readonly branches: (options?: BranchOptions) => Effect.Effect<BranchList>;
+    readonly status: () => Effect.Effect<FileStatus[]>;
+    readonly diff: (mode: Mode, options?: DiffOptions) => Effect.Effect<FileDiff.Info[], DiffError>;
+}
+export interface Interface extends Adapter, State.Transformable<VcsEditor> {
+    readonly base: () => Effect.Effect<Base | null, DiffError>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@opencode/Vcs", 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<"location">>;

package/dist/types/websearch.d.ts

@@ -0,0 +1,74 @@
+export * as WebSearch from "./websearch.js";
+import { WebSearch } from "@opencode/schema/websearch";
+import type { Session } from "@opencode/schema/session";
+import { Context, Effect, Schema } from "effect";
+import { State } from "./state.js";
+export declare const ID: Schema.brand<Schema.String, "WebSearch.ID">;
+export type ID = WebSearch.ID;
+export declare const Provider: Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "WebSearch.ID">;
+    readonly name: Schema.String;
+}>;
+export type Provider = WebSearch.Provider;
+export { Event } from "@opencode/schema/websearch";
+export declare const Input: Schema.Struct<{
+    readonly query: Schema.String;
+    readonly providerID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "WebSearch.ID">>>, Schema.optionalKey<Schema.brand<Schema.String, "WebSearch.ID">>, never, never>;
+}>;
+export type Input = WebSearch.Input;
+export type ProviderInput = WebSearch.ProviderInput;
+export declare const Result: Schema.Struct<{
+    readonly url: Schema.String;
+    readonly title: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly content: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly time: Schema.Struct<{
+        readonly published: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Finite>>, Schema.optionalKey<Schema.Finite>, never, never>;
+    }>;
+}>;
+export type Result = WebSearch.Result;
+export declare const Response: typeof WebSearch.Response;
+export type Response = WebSearch.Response;
+export declare const ProviderKey = "websearch:provider";
+export declare const Selection: Schema.Union<readonly [Schema.brand<Schema.String, "WebSearch.ID">, Schema.Literal<"random">, Schema.Literal<false>]>;
+export type Selection = typeof Selection.Type;
+export interface ProviderImplementation extends Provider {
+    readonly execute: (input: ProviderInput) => Effect.Effect<readonly Result[], unknown>;
+}
+declare const ProviderRequiredError_base: Schema.Class<ProviderRequiredError, Schema.TaggedStruct<"WebSearch.ProviderRequired", {}>, import("effect/Cause").YieldableError>;
+export declare class ProviderRequiredError extends ProviderRequiredError_base {
+}
+declare const ProviderNotFoundError_base: Schema.Class<ProviderNotFoundError, Schema.TaggedStruct<"WebSearch.ProviderNotFound", {
+    readonly providerID: Schema.brand<Schema.String, "WebSearch.ID">;
+}>, import("effect/Cause").YieldableError>;
+export declare class ProviderNotFoundError extends ProviderNotFoundError_base {
+}
+declare const DisabledError_base: Schema.Class<DisabledError, Schema.TaggedStruct<"WebSearch.Disabled", {}>, import("effect/Cause").YieldableError>;
+export declare class DisabledError extends DisabledError_base {
+}
+declare const RequestError_base: Schema.Class<RequestError, Schema.TaggedStruct<"WebSearch.Request", {
+    readonly providerID: Schema.brand<Schema.String, "WebSearch.ID">;
+    readonly cause: Schema.Defect;
+}>, import("effect/Cause").YieldableError>;
+export declare class RequestError extends RequestError_base {
+}
+export type Error = ProviderRequiredError | ProviderNotFoundError | DisabledError | RequestError;
+export interface Interface extends State.Transformable<Editor> {
+    readonly providers: () => Effect.Effect<readonly Provider[]>;
+    readonly default: () => Effect.Effect<Provider | undefined, DisabledError>;
+    readonly select: (selection: Selection) => Effect.Effect<void>;
+    readonly query: (input: Input, options?: {
+        readonly sessionID?: Session.ID;
+        readonly onProvider?: (provider: Provider) => Effect.Effect<void>;
+    }) => Effect.Effect<Response, Error>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@opencode/WebSearch", Interface>;
+export declare class Service extends Service_base {
+}
+export type Editor = {
+    add: (provider: ProviderImplementation) => void;
+    default: {
+        get: () => Selection | undefined;
+        set: (selection: Selection) => void;
+    };
+};
+export declare const node: import("@opencode/util/effect/layer-node").Provider<Service, never, import("@opencode/util/effect/layer-node").Tag<"location">>;

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

@@ -0,0 +1,4 @@
+export * as WellKnownPlugin from "./plugin.js";
+import { Bus } from "../bus.js";
+import { WellKnown } from "../wellknown.js";
+export declare const Plugin: import("@opencode/plugin/effect/plugin").Plugin<import("effect/Scope").Scope | Bus.Service | WellKnown.Service>;

package/dist/types/wellknown.d.ts

@@ -0,0 +1,106 @@
+export * as WellKnown from "./wellknown.js";
+import { Integration } from "@opencode/schema/integration";
+import { Context, Effect, Schema } from "effect";
+import { HttpClient } from "effect/unstable/http";
+export interface Auth extends Schema.Schema.Type<typeof Auth> {
+}
+export declare const Auth: Schema.Struct<{
+    readonly command: Schema.$Array<Schema.String>;
+    readonly env: Schema.String;
+}>;
+export interface RemoteConfig extends Schema.Schema.Type<typeof RemoteConfig> {
+}
+export declare const RemoteConfig: Schema.Struct<{
+    readonly url: Schema.String;
+    readonly headers: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
+}>;
+export interface Config extends Schema.Schema.Type<typeof Config> {
+}
+export declare const Config: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+export interface Manifest extends Schema.Schema.Type<typeof Manifest> {
+}
+export declare const Manifest: Schema.Struct<{
+    readonly auth: Schema.optional<Schema.Struct<{
+        readonly command: Schema.$Array<Schema.String>;
+        readonly env: Schema.String;
+    }>>;
+    readonly config: Schema.optional<Schema.NullOr<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>>;
+    readonly remote_config: Schema.optional<Schema.Struct<{
+        readonly url: Schema.String;
+        readonly headers: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
+    }>>;
+}>;
+export interface ResolveInput {
+    readonly origin: string;
+    readonly variables?: Readonly<Record<string, string>>;
+}
+export interface Entry {
+    readonly origin: string;
+    readonly integrationID: Integration.ID;
+    readonly manifest: Manifest;
+}
+export interface Interface {
+    readonly entries: () => Effect.Effect<readonly Entry[], Error>;
+    readonly snapshot: () => readonly Entry[];
+    readonly refresh: () => Effect.Effect<boolean, Error>;
+    readonly add: (origin: string) => Effect.Effect<Entry, Error>;
+    readonly remove: (origin: string) => Effect.Effect<void>;
+    readonly resolve: (entry: Entry, variables: Readonly<Record<string, string>>) => Effect.Effect<Config[], Error>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@opencode/WellKnown", Interface>;
+export declare class Service extends Service_base {
+}
+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<"wellknown.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<{}>;
+    }> & {
+        type: "wellknown.updated";
+        durability: "ephemeral";
+        durable: undefined;
+        data: Schema.Struct<{}>;
+    };
+};
+export declare const inspect: (origin: string) => Effect.Effect<{
+    readonly config?: {
+        readonly [x: string]: Schema.Json;
+    } | null | undefined;
+    readonly auth?: {
+        readonly command: readonly string[];
+        readonly env: string;
+    } | undefined;
+    readonly remote_config?: {
+        readonly url: string;
+        readonly headers?: {
+            readonly [x: string]: string;
+        } | undefined;
+    } | undefined;
+}, Error, HttpClient.HttpClient>;
+export declare const resolve: (input: ResolveInput) => Effect.Effect<{
+    readonly [x: string]: Schema.Json;
+}[], Error, HttpClient.HttpClient>;
+export declare const node: import("@opencode/util/effect/layer-node").Provider<Service, never, import("@opencode/util/effect/layer-node").Tag<"global">>;

package/dist/types/workspace/driver.d.ts

@@ -0,0 +1,72 @@
+export * as WorkspaceDriver from "./driver.js";
+import { Workspace } from "@opencode/schema/workspace";
+import { Context, Effect, Schema } from "effect";
+import type { Scope } from "effect";
+import type { EnvironmentDriver } from "../environment/driver.js";
+/**
+ * Smallest provider-owned JSON value required to reconnect to the same
+ * provider resource. Core stores it opaquely and hands it back; only the
+ * owning driver reads inside.
+ */
+export declare const Binding: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+export type Binding = typeof Binding.Type;
+declare const Error_base: Schema.Class<Error, Schema.TaggedStruct<"WorkspaceDriver.Error", {
+    readonly message: Schema.optional<Schema.String>;
+    readonly cause: Schema.optional<Schema.Defect>;
+}>, import("effect/Cause").YieldableError>;
+export declare class Error extends Error_base {
+}
+declare const ProviderNotFound_base: Schema.Class<ProviderNotFound, Schema.TaggedStruct<"WorkspaceDriver.ProviderNotFound", {
+    readonly provider: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class ProviderNotFound extends ProviderNotFound_base {
+}
+export interface Interface {
+    /**
+     * Get-or-create the provider resource backing this logical workspace.
+     *
+     * MUST be idempotent per `workspaceID`: core retries the same ID after
+     * failures and process crashes, including a crash between a successful
+     * create and the binding being persisted, and another process may race the
+     * same ID. Key the resource by `workspaceID` (a provider tag or a
+     * deterministic name) and adopt an existing match instead of creating a
+     * duplicate.
+     */
+    readonly create: (input: {
+        readonly workspaceID: Workspace.ID;
+    }) => Effect.Effect<{
+        readonly binding: Binding;
+    }, Error>;
+    readonly connect: (input: {
+        readonly workspaceID: Workspace.ID;
+        readonly binding: Binding;
+        readonly saveBinding: (binding: Binding) => Effect.Effect<void>;
+    }) => Effect.Effect<EnvironmentDriver.Driver, Error, Scope.Scope>;
+    readonly suspendForIdle: (input: {
+        readonly workspaceID: Workspace.ID;
+        readonly binding: Binding;
+        readonly saveBinding: (binding: Binding) => Effect.Effect<void>;
+    }) => Effect.Effect<void, Error>;
+    /**
+     * Release the provider resource for this workspace.
+     *
+     * `binding` is null when none was persisted: the workspace was never
+     * provisioned, or provisioning was interrupted mid-create. Look up any
+     * resource previously created for `workspaceID` and clean it up, treating
+     * absence as success.
+     */
+    readonly destroy: (input: {
+        readonly workspaceID: Workspace.ID;
+        readonly binding: Binding | null;
+    }) => Effect.Effect<void, Error>;
+}
+export declare const make: (driver: Interface) => Interface;
+export interface Registry {
+    readonly get: (provider: string) => Effect.Effect<Interface, ProviderNotFound>;
+}
+declare const RegistryService_base: Context.ServiceClass<RegistryService, "@opencode/WorkspaceDriverRegistry", Registry>;
+export declare class RegistryService extends RegistryService_base {
+}
+export declare const registry: (drivers: Readonly<Record<string, Interface>>) => Registry;
+export declare const registryNode: (drivers: Readonly<Record<string, Interface>>) => import("@opencode/util/effect/layer-node").Provider<RegistryService, never, import("@opencode/util/effect/layer-node").Tag<"global">>;
+export declare const node: import("@opencode/util/effect/layer-node").Provider<RegistryService, never, import("@opencode/util/effect/layer-node").Tag<"global">>;

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

@@ -0,0 +1,89 @@
+export declare const WorkspaceTable: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    name: "workspace";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "workspace";
+            dataType: "string";
+            data: string & import("effect/Brand").Brand<"Workspace.ID">;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        provider: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "workspace";
+            dataType: "string";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        binding: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "workspace";
+            dataType: "object json";
+            data: {
+                readonly [x: string]: import("effect/Schema").Json;
+            };
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        created_at: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "workspace";
+            dataType: "number int53";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        last_used_at: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "workspace";
+            dataType: "number int53";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+    };
+    dialect: "sqlite";
+}>;

package/dist/types/workspace.d.ts

@@ -0,0 +1,61 @@
+export * as Workspace from "./workspace.js";
+import { Workspace } from "@opencode/schema/workspace";
+import { Context, Duration, Effect, Schema } from "effect";
+import type { EnvironmentDriver } from "./environment/driver.js";
+import { WorkspaceDriver } from "./workspace/driver.js";
+export declare const ID: Schema.brand<Schema.String, "Workspace.ID"> & {
+    ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+    create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+};
+export type ID = Workspace.ID;
+declare const Info_base: Schema.Class<Info, Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "Workspace.ID"> & {
+        ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+        create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+    };
+    readonly provider: Schema.String;
+    readonly binding: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+    readonly createdAt: Schema.Number;
+    readonly lastUsedAt: Schema.Number;
+}>, {}>;
+export declare class Info extends Info_base {
+}
+declare const NotFound_base: Schema.Class<NotFound, Schema.TaggedStruct<"Workspace.NotFound", {
+    readonly workspaceID: Schema.brand<Schema.String, "Workspace.ID"> & {
+        ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+        create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+    };
+}>, import("effect/Cause").YieldableError>;
+export declare class NotFound extends NotFound_base {
+}
+declare const CreateConflict_base: Schema.Class<CreateConflict, Schema.TaggedStruct<"Workspace.CreateConflict", {
+    readonly workspaceID: Schema.brand<Schema.String, "Workspace.ID"> & {
+        ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+        create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+    };
+    readonly provider: Schema.String;
+    readonly existingProvider: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class CreateConflict extends CreateConflict_base {
+}
+export interface Interface {
+    /** Instantly commits a logical workspace ID. No provider work happens here. */
+    readonly create: (input: {
+        readonly id?: ID;
+        readonly provider: string;
+    }) => Effect.Effect<ID, CreateConflict | WorkspaceDriver.ProviderNotFound>;
+    /** Starts or joins the shared attempt that makes the backing resource real, then returns it. */
+    readonly provision: (workspaceID: ID) => Effect.Effect<Info, NotFound | WorkspaceDriver.Error | WorkspaceDriver.ProviderNotFound>;
+    readonly connect: (workspaceID: ID) => Effect.Effect<EnvironmentDriver.Driver, NotFound | WorkspaceDriver.Error | WorkspaceDriver.ProviderNotFound>;
+    /** Makes the workspace absent; reports whether this call destroyed an existing workspace. */
+    readonly destroy: (workspaceID: ID) => Effect.Effect<Workspace.DestroyResult, WorkspaceDriver.Error | WorkspaceDriver.ProviderNotFound>;
+}
+export interface Options {
+    readonly idleThreshold?: Duration.Input;
+    readonly pollInterval?: Duration.Input;
+}
+declare const Service_base: Context.ServiceClass<Service, "@opencode/Workspace", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const configured: (options?: Options) => import("@opencode/util/effect/layer-node").Provider<Service, never, import("@opencode/util/effect/layer-node").Tag<"global">>;
+export declare const node: import("@opencode/util/effect/layer-node").Provider<Service, never, import("@opencode/util/effect/layer-node").Tag<"global">>;

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/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>;