@opencode/core 0.0.0-beta-19275

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

@@ -0,0 +1,300 @@
+import type { EffectDrizzleSqlite } from "../database/drizzle.js";
+import type { AbsolutePath } from "../schema.js";
+import { ProjectSchema } from "./schema.js";
+type DatabaseClient = EffectDrizzleSqlite.EffectSQLiteDatabase;
+type Transaction = Parameters<Parameters<DatabaseClient["transaction"]>[0]>[0];
+export declare const ProjectTable: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    name: "project";
+    schema: undefined;
+    columns: {
+        time_initialized: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "project";
+            dataType: "number int53";
+            data: number;
+            driverParam: number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        sandboxes: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "project";
+            dataType: "custom";
+            data: (string & import("effect/Brand").Brand<"AbsolutePath">)[];
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        commands: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "project";
+            dataType: "object json";
+            data: {
+                start?: string;
+            };
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        time_created: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "project";
+            dataType: "number int53";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: true;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        time_updated: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "project";
+            dataType: "number int53";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "project";
+            dataType: "string";
+            data: string & import("effect/Brand").Brand<"Project.ID">;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        worktree: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "project";
+            dataType: "custom";
+            data: string & import("effect/Brand").Brand<"AbsolutePath">;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        vcs: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "project";
+            dataType: "string";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        name: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "project";
+            dataType: "string";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        icon_url: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "project";
+            dataType: "string";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        icon_url_override: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "project";
+            dataType: "string";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        icon_color: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "project";
+            dataType: "string";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+    };
+    dialect: "sqlite";
+}>;
+/** @deprecated Use WorktreeTable from worktree/sql instead. */
+export declare const ProjectDirectoryTable: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    name: "project_directory";
+    schema: undefined;
+    columns: {
+        project_id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "project_directory";
+            dataType: "string";
+            data: string & import("effect/Brand").Brand<"Project.ID">;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        directory: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "project_directory";
+            dataType: "custom";
+            data: string & import("effect/Brand").Brand<"AbsolutePath">;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        type: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "project_directory";
+            dataType: "string";
+            data: "root" | "main" | "git_worktree";
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        strategy: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "project_directory";
+            dataType: "string";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        time_created: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "project_directory";
+            dataType: "number int53";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: true;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+    };
+    dialect: "sqlite";
+}>;
+export declare function upsertProject(db: DatabaseClient | Transaction, project: {
+    readonly id: ProjectSchema.ID;
+    readonly canonical: AbsolutePath;
+    readonly vcs?: ProjectSchema.Vcs;
+}): import("drizzle-orm/effect-core").QueryEffectKind<EffectDrizzleSqlite.EffectSQLiteQueryEffectHKT, EffectDrizzleSqlite.EffectSQLiteRunResult>;
+export {};

package/dist/types/project.d.ts

@@ -0,0 +1,101 @@
+export * as Project from "./project.js";
+import { Context, Effect, Schema } from "effect";
+import { AbsolutePath } from "./schema.js";
+import { FSUtil } from "@opencode/util/fs-util";
+import { ProjectSchema } from "./project/schema.js";
+export declare const ID: Schema.brand<Schema.String, "Project.ID"> & {
+    global: string & import("effect/Brand").Brand<"Project.ID">;
+};
+export type ID = ProjectSchema.ID;
+export declare const Vcs: Schema.Struct<{
+    readonly type: Schema.String;
+    readonly store: Schema.brand<Schema.String, "AbsolutePath">;
+}>;
+export type Vcs = ProjectSchema.Vcs;
+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 = ProjectSchema.Current;
+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 = ProjectSchema.UpdateInput;
+declare const NotFoundError_base: Schema.Class<NotFoundError, Schema.TaggedStruct<"Project.NotFoundError", {
+    readonly projectID: Schema.brand<Schema.String, "Project.ID"> & {
+        global: string & import("effect/Brand").Brand<"Project.ID">;
+    };
+}>, import("effect/Cause").YieldableError>;
+export declare class NotFoundError extends NotFoundError_base {
+}
+export interface Resolved {
+    readonly previous?: ID;
+    readonly id: ID;
+    readonly directory: AbsolutePath;
+    readonly canonical: AbsolutePath;
+    readonly vcs?: Vcs;
+}
+export declare const root: (fs: FSUtil.Interface, input: string & import("effect/Brand").Brand<"AbsolutePath">, markers?: readonly string[] | undefined) => Effect.Effect<(string & import("effect/Brand").Brand<"AbsolutePath">) | undefined, never, never>;
+export interface Interface {
+    readonly list: () => Effect.Effect<ReadonlyArray<Info>>;
+    readonly update: (input: UpdateInput) => Effect.Effect<Info, NotFoundError>;
+    /** Resolves and persists the owning Project. */
+    readonly resolve: (input: AbsolutePath, options?: {
+        readonly discovery?: boolean;
+    }) => Effect.Effect<Resolved>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@opencode/Project", 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/provider.d.ts

@@ -0,0 +1,111 @@
+export * as Provider from "./provider.js";
+import { Effect, Schema } from "effect";
+import { Provider } from "@opencode/schema/provider";
+import type { ProviderPackageDefinition } from "@opencode/ai";
+import { Npm } from "@opencode/util/npm";
+import type { DeepMutable } from "./schema.js";
+export declare const ID: Schema.brand<Schema.String, "Provider.ID"> & {
+    opencode: string & import("effect/Brand").Brand<"Provider.ID">;
+    anthropic: string & import("effect/Brand").Brand<"Provider.ID">;
+    openai: string & import("effect/Brand").Brand<"Provider.ID">;
+    google: string & import("effect/Brand").Brand<"Provider.ID">;
+    googleVertex: string & import("effect/Brand").Brand<"Provider.ID">;
+    githubCopilot: string & import("effect/Brand").Brand<"Provider.ID">;
+    amazonBedrock: string & import("effect/Brand").Brand<"Provider.ID">;
+    azure: string & import("effect/Brand").Brand<"Provider.ID">;
+    openrouter: string & import("effect/Brand").Brand<"Provider.ID">;
+    mistral: string & import("effect/Brand").Brand<"Provider.ID">;
+    gitlab: string & import("effect/Brand").Brand<"Provider.ID">;
+};
+export type ID = typeof ID.Type;
+export declare const AISDK_PREFIX = "aisdk:";
+export declare const isAISDK: (value: string | undefined) => value is string;
+export declare const aisdk: (value: string) => string;
+export declare function packageName(value: string): string;
+export declare function packageName(value: undefined): undefined;
+export declare function packageName(value: string | undefined): string | undefined;
+type Json = Schema.Schema.Type<typeof Schema.Json>;
+declare const LoadError_base: Schema.Class<LoadError, Schema.TaggedStruct<"Provider.LoadError", {
+    readonly package: Schema.String;
+    readonly cause: Schema.Defect;
+}>, import("effect/Cause").YieldableError>;
+export declare class LoadError extends LoadError_base {
+}
+export type ProviderPackage = ProviderPackageDefinition;
+export declare const loadPackage: (input: string, npm?: Npm.Interface | undefined) => Effect.Effect<ProviderPackageDefinition<import("@opencode/ai").ProviderPackageSettings, {
+    readonly [x: string]: unknown;
+}, import("@opencode/ai/route").CompactionOperations | undefined>, LoadError, never>;
+export declare function mergeOverlay(base: Readonly<Record<string, unknown>> | undefined, overlay: Readonly<Record<string, unknown>> | undefined): Record<string, Json> | undefined;
+export declare function mergeHeaders(base: Readonly<Record<string, string>> | undefined, overlay: Readonly<Record<string, string>> | undefined): {
+    [k: string]: string;
+} | undefined;
+export declare const Request: Schema.Struct<{
+    readonly settings: Schema.withConstructorDefault<Schema.$Record<Schema.String, Schema.Any>>;
+    readonly headers: Schema.$Record<Schema.String, Schema.String>;
+    readonly body: Schema.$Record<Schema.String, Schema.Any>;
+}>;
+export type Request = Provider.Request;
+export declare const Settings: Schema.$Record<Schema.String, Schema.Any>;
+export type Settings = Provider.Settings;
+export declare const Info: Schema.Struct<{
+    readonly settings: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Any>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Any>>, never, never>;
+    readonly headers: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.String>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>, never, never>;
+    readonly body: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Any>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Any>>, never, never>;
+    readonly id: Schema.brand<Schema.String, "Provider.ID"> & {
+        opencode: string & import("effect/Brand").Brand<"Provider.ID">;
+        anthropic: string & import("effect/Brand").Brand<"Provider.ID">;
+        openai: string & import("effect/Brand").Brand<"Provider.ID">;
+        google: string & import("effect/Brand").Brand<"Provider.ID">;
+        googleVertex: string & import("effect/Brand").Brand<"Provider.ID">;
+        githubCopilot: string & import("effect/Brand").Brand<"Provider.ID">;
+        amazonBedrock: string & import("effect/Brand").Brand<"Provider.ID">;
+        azure: string & import("effect/Brand").Brand<"Provider.ID">;
+        openrouter: string & import("effect/Brand").Brand<"Provider.ID">;
+        mistral: string & import("effect/Brand").Brand<"Provider.ID">;
+        gitlab: string & import("effect/Brand").Brand<"Provider.ID">;
+    };
+    readonly canonical: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Provider.ID"> & {
+        opencode: string & import("effect/Brand").Brand<"Provider.ID">;
+        anthropic: string & import("effect/Brand").Brand<"Provider.ID">;
+        openai: string & import("effect/Brand").Brand<"Provider.ID">;
+        google: string & import("effect/Brand").Brand<"Provider.ID">;
+        googleVertex: string & import("effect/Brand").Brand<"Provider.ID">;
+        githubCopilot: string & import("effect/Brand").Brand<"Provider.ID">;
+        amazonBedrock: string & import("effect/Brand").Brand<"Provider.ID">;
+        azure: string & import("effect/Brand").Brand<"Provider.ID">;
+        openrouter: string & import("effect/Brand").Brand<"Provider.ID">;
+        mistral: string & import("effect/Brand").Brand<"Provider.ID">;
+        gitlab: string & import("effect/Brand").Brand<"Provider.ID">;
+    }>>, Schema.optionalKey<Schema.brand<Schema.String, "Provider.ID"> & {
+        opencode: string & import("effect/Brand").Brand<"Provider.ID">;
+        anthropic: string & import("effect/Brand").Brand<"Provider.ID">;
+        openai: string & import("effect/Brand").Brand<"Provider.ID">;
+        google: string & import("effect/Brand").Brand<"Provider.ID">;
+        googleVertex: string & import("effect/Brand").Brand<"Provider.ID">;
+        githubCopilot: string & import("effect/Brand").Brand<"Provider.ID">;
+        amazonBedrock: string & import("effect/Brand").Brand<"Provider.ID">;
+        azure: string & import("effect/Brand").Brand<"Provider.ID">;
+        openrouter: string & import("effect/Brand").Brand<"Provider.ID">;
+        mistral: string & import("effect/Brand").Brand<"Provider.ID">;
+        gitlab: string & import("effect/Brand").Brand<"Provider.ID">;
+    }>, never, never>;
+    readonly integrationID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Integration.ID">>>, Schema.optionalKey<Schema.brand<Schema.String, "Integration.ID">>, never, never>;
+    readonly name: Schema.String;
+    readonly activation: Schema.Literals<readonly ["auto", "enabled", "disabled"]>;
+    readonly package: Schema.String;
+    readonly compaction: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Struct<{
+        readonly mode: Schema.Literal<"local">;
+    }>, Schema.Struct<{
+        readonly mode: Schema.Literal<"provider">;
+        readonly threshold: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+    }>]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
+        readonly mode: Schema.Literal<"local">;
+    }>, Schema.Struct<{
+        readonly mode: Schema.Literal<"provider">;
+        readonly threshold: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+    }>]>>, never, never>;
+}> & {
+    empty: (id: Provider.ID) => Provider.Info;
+};
+export type Info = Provider.Info;
+export type MutableInfo = DeepMutable<Info>;

package/dist/types/pty/protocol.d.ts

@@ -0,0 +1,5 @@
+export * as PtyProtocol from "./protocol.js";
+export declare const REPLAY_CHUNK: number;
+export declare function metaFrame(cursor: number): Uint8Array<ArrayBuffer>;
+export declare function chunks(data: string): string[];
+export declare function decodeInput(message: string | Uint8Array | ArrayBuffer): string | undefined;

package/dist/types/pty/pty.bun.d.ts

@@ -0,0 +1,4 @@
+import type { Opts, Proc } from "./pty.js";
+export type { Disp, Exit, Opts, Proc } from "./pty.js";
+declare function spawnPty(file: string, args: string[], opts: Opts): Proc;
+export { spawnPty as spawn };

package/dist/types/pty/pty.d.ts

@@ -0,0 +1,22 @@
+export type Disp = {
+    dispose(): void;
+};
+export type Exit = {
+    exitCode: number;
+    signal?: number | string;
+};
+export type Opts = {
+    name: string;
+    cols?: number;
+    rows?: number;
+    cwd?: string;
+    env?: Record<string, string>;
+};
+export type Proc = {
+    pid: number;
+    onData(listener: (data: string) => void): Disp;
+    onExit(listener: (event: Exit) => void): Disp;
+    write(data: string): void;
+    resize(cols: number, rows: number): void;
+    kill(signal?: string): void;
+};

package/dist/types/pty/pty.node.d.ts

@@ -0,0 +1,4 @@
+import type { Opts, Proc } from "./pty.js";
+export type { Disp, Exit, Opts, Proc } from "./pty.js";
+declare function spawnPty(file: string, args: string[], opts: Opts): Proc;
+export { spawnPty as spawn };

package/dist/types/pty/pty.workerd.d.ts

@@ -0,0 +1,3 @@
+import type { Proc } from "./pty.js";
+export type { Disp, Exit, Opts, Proc } from "./pty.js";
+export declare function spawn(): Proc;

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

@@ -0,0 +1 @@
+export { ID as PtyID } from "@opencode/schema/pty";

package/dist/types/pty/ticket.d.ts

@@ -0,0 +1,24 @@
+export * as PtyTicket from "./ticket.js";
+import type { Workspace } from "@opencode/schema/workspace";
+import { PtyID } from "./schema.js";
+import { Context, Duration, Effect } from "effect";
+export declare const ConnectToken: import("effect/Schema").Struct<{
+    readonly ticket: import("effect/Schema").String;
+    readonly expires_in: import("effect/Schema").Int;
+}>;
+export type Scope = {
+    readonly ptyID: PtyID;
+    readonly directory?: string;
+    readonly workspaceID?: Workspace.ID;
+};
+export interface Interface {
+    issue(input: Scope): Effect.Effect<typeof ConnectToken.Type>;
+    consume(input: Scope & {
+        readonly ticket: string;
+    }): Effect.Effect<boolean>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@opencode/PtyTicket", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const make: (ttl?: Duration.Input) => Effect.Effect<Interface, never, never>;
+export declare const node: import("@opencode/util/effect/layer-node").Provider<Service, never, import("@opencode/util/effect/layer-node").Tag<"global">>;