@opencode-ai/core 0.0.0-next-17293

package/dist/types/pty.d.ts

@@ -0,0 +1,87 @@
+export * as Pty from "./pty.js";
+import { Context, Effect, Layer, Schema, Types } from "effect";
+import { Config } from "./config.js";
+import { Bus } from "./bus.js";
+import { Location } from "./location.js";
+import { PtyID } from "./pty/schema.js";
+import { ShellSelect } from "./shell/select.js";
+import { Global } from "@opencode-ai/util/global";
+export declare const Info: Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "PtyID"> & {
+        create: () => string & import("effect/Brand").Brand<"PtyID">;
+        ascending: (id?: string) => string & import("effect/Brand").Brand<"PtyID">;
+    };
+    readonly title: Schema.String;
+    readonly command: Schema.String;
+    readonly args: Schema.$Array<Schema.String>;
+    readonly cwd: Schema.String;
+    readonly status: Schema.Literals<readonly ["running", "exited"]>;
+    readonly pid: Schema.Int;
+    readonly exitCode: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+}>;
+export type Info = Types.DeepMutable<typeof Info.Type>;
+export declare const CreateInput: Schema.Struct<{
+    readonly command: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly args: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
+    readonly cwd: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly title: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly env: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.String>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>, never, never>;
+}>;
+export type CreateInput = Types.DeepMutable<typeof CreateInput.Type>;
+export declare const UpdateInput: Schema.Struct<{
+    readonly title: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly size: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+        readonly rows: Schema.Int;
+        readonly cols: Schema.Int;
+    }>>>, Schema.optionalKey<Schema.Struct<{
+        readonly rows: Schema.Int;
+        readonly cols: Schema.Int;
+    }>>, never, never>;
+}>;
+export type UpdateInput = Types.DeepMutable<typeof UpdateInput.Type>;
+export { Event } from "@opencode-ai/schema/pty";
+export type AttachInput = {
+    readonly cursor?: number;
+    readonly onData: (chunk: string) => void;
+    readonly onEnd: (event: {
+        exitCode?: number;
+    }) => void;
+};
+export type Attachment = {
+    readonly replay: string;
+    readonly cursor: number;
+    readonly write: (data: string) => void;
+    readonly activate: () => void;
+    readonly detach: () => void;
+};
+declare const NotFoundError_base: Schema.Class<NotFoundError, Schema.TaggedStruct<"Pty.NotFoundError", {
+    readonly ptyID: Schema.brand<Schema.String, "PtyID"> & {
+        create: () => string & import("effect/Brand").Brand<"PtyID">;
+        ascending: (id?: string) => string & import("effect/Brand").Brand<"PtyID">;
+    };
+}>, import("effect/Cause").YieldableError>;
+export declare class NotFoundError extends NotFoundError_base {
+}
+declare const ExitedError_base: Schema.Class<ExitedError, Schema.TaggedStruct<"Pty.ExitedError", {
+    readonly ptyID: Schema.brand<Schema.String, "PtyID"> & {
+        create: () => string & import("effect/Brand").Brand<"PtyID">;
+        ascending: (id?: string) => string & import("effect/Brand").Brand<"PtyID">;
+    };
+}>, import("effect/Cause").YieldableError>;
+export declare class ExitedError extends ExitedError_base {
+}
+export interface Interface {
+    readonly list: () => Effect.Effect<Info[]>;
+    readonly get: (id: PtyID) => Effect.Effect<Info, NotFoundError>;
+    readonly create: (input: CreateInput) => Effect.Effect<Info>;
+    readonly update: (id: PtyID, input: UpdateInput) => Effect.Effect<Info, NotFoundError>;
+    readonly remove: (id: PtyID) => Effect.Effect<void, NotFoundError>;
+    readonly write: (id: PtyID, data: string) => Effect.Effect<void, NotFoundError>;
+    readonly attach: (id: PtyID, input: AttachInput) => Effect.Effect<Attachment, NotFoundError | ExitedError>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@opencode/Pty", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const layer: (options?: ShellSelect.Options) => Layer.Layer<Service, never, Global.Service | Location.Service | Bus.Service | Config.Service>;
+export declare function configured(options?: ShellSelect.Options): import("@opencode-ai/util/effect/layer-node").Node<Service, never, import("@opencode-ai/util/effect/layer-node").Tag<"location">>;
+export declare const node: import("@opencode-ai/util/effect/layer-node").Node<Service, never, import("@opencode-ai/util/effect/layer-node").Tag<"location">>;

package/dist/types/question.d.ts

@@ -0,0 +1,105 @@
+export * as Question from "./question.js";
+import { Context, Effect, Schema } from "effect";
+import { SessionSchema } from "./session/schema.js";
+export declare const ID: Schema.brand<Schema.String, "Question.ID"> & {
+    create: () => string & import("effect/Brand").Brand<"Question.ID">;
+    ascending: (id?: string) => string & import("effect/Brand").Brand<"Question.ID">;
+};
+export type ID = typeof ID.Type;
+export declare const Option: Schema.Struct<{
+    readonly label: Schema.String;
+    readonly description: Schema.String;
+}>;
+export type Option = typeof Option.Type;
+export declare const Info: Schema.Struct<{
+    readonly custom: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    readonly question: Schema.String;
+    readonly header: Schema.String;
+    readonly options: Schema.$Array<Schema.Struct<{
+        readonly label: Schema.String;
+        readonly description: Schema.String;
+    }>>;
+    readonly multiple: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+}>;
+export type Info = typeof Info.Type;
+export declare const Prompt: Schema.Struct<{
+    question: Schema.String;
+    header: Schema.String;
+    options: Schema.$Array<Schema.Struct<{
+        readonly label: Schema.String;
+        readonly description: Schema.String;
+    }>>;
+    multiple: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+}>;
+export type Prompt = typeof Prompt.Type;
+export declare const Tool: Schema.Struct<{
+    readonly messageID: Schema.String;
+    readonly id: Schema.String;
+}>;
+export type Tool = typeof Tool.Type;
+export declare const Request: Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "Question.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Question.ID">;
+        ascending: (id?: string) => string & import("effect/Brand").Brand<"Question.ID">;
+    };
+    readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
+        create: () => string & import("effect/Brand").Brand<"SessionID">;
+        descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+    };
+    readonly questions: Schema.$Array<Schema.Struct<{
+        readonly custom: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+        readonly question: Schema.String;
+        readonly header: Schema.String;
+        readonly options: Schema.$Array<Schema.Struct<{
+            readonly label: Schema.String;
+            readonly description: Schema.String;
+        }>>;
+        readonly multiple: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    }>>;
+    readonly tool: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+        readonly messageID: Schema.String;
+        readonly id: Schema.String;
+    }>>>, Schema.optionalKey<Schema.Struct<{
+        readonly messageID: Schema.String;
+        readonly id: Schema.String;
+    }>>, never, never>;
+}>;
+export type Request = typeof Request.Type;
+export declare const Answer: Schema.$Array<Schema.String>;
+export type Answer = typeof Answer.Type;
+export declare const Reply: Schema.Struct<{
+    readonly answers: Schema.$Array<Schema.$Array<Schema.String>>;
+}>;
+export type Reply = typeof Reply.Type;
+export { Event } from "@opencode-ai/schema/question";
+declare const RejectedError_base: Schema.Class<RejectedError, Schema.TaggedStruct<"Question.RejectedError", {}>, import("effect/Cause").YieldableError>;
+export declare class RejectedError extends RejectedError_base {
+    get message(): string;
+}
+declare const NotFoundError_base: Schema.Class<NotFoundError, Schema.TaggedStruct<"Question.NotFoundError", {
+    readonly requestID: Schema.brand<Schema.String, "Question.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Question.ID">;
+        ascending: (id?: string) => string & import("effect/Brand").Brand<"Question.ID">;
+    };
+}>, import("effect/Cause").YieldableError>;
+export declare class NotFoundError extends NotFoundError_base {
+}
+export interface AskInput {
+    readonly sessionID: SessionSchema.ID;
+    readonly questions: ReadonlyArray<Info>;
+    readonly tool?: Tool;
+}
+export interface ReplyInput {
+    readonly requestID: ID;
+    readonly answers: ReadonlyArray<Answer>;
+}
+export interface Interface {
+    readonly ask: (input: AskInput) => Effect.Effect<ReadonlyArray<Answer>, RejectedError>;
+    readonly reply: (input: ReplyInput) => Effect.Effect<void, NotFoundError>;
+    readonly reject: (requestID: ID) => Effect.Effect<void, NotFoundError>;
+    readonly list: () => Effect.Effect<ReadonlyArray<Request>>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@opencode/Question", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const node: import("@opencode-ai/util/effect/layer-node").Node<Service, never, import("@opencode-ai/util/effect/layer-node").Tag<"location">>;

package/dist/types/reference/instructions.d.ts

@@ -0,0 +1,10 @@
+export * as ReferenceInstructions from "./instructions.js";
+import { Context, Effect } from "effect";
+import { Instructions } from "../instructions/index.js";
+export interface Interface {
+    readonly load: () => Effect.Effect<Instructions.List>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@opencode/ReferenceInstructions", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const node: import("@opencode-ai/util/effect/layer-node").Node<Service, never, import("@opencode-ai/util/effect/layer-node").Tag<"location">>;

package/dist/types/reference.d.ts

@@ -0,0 +1,64 @@
+export * as Reference from "./reference.js";
+import { Context, Effect } from "effect";
+import { Reference } from "@opencode-ai/schema/reference";
+import { State } from "./state.js";
+export declare const LocalSource: import("effect/Schema").Struct<{
+    readonly type: import("effect/Schema").Literal<"local">;
+    readonly path: import("effect/Schema").brand<import("effect/Schema").String, "AbsolutePath">;
+    readonly description: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").String>>, import("effect/Schema").optionalKey<import("effect/Schema").String>, never, never>;
+    readonly hidden: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Boolean>>, import("effect/Schema").optionalKey<import("effect/Schema").Boolean>, never, never>;
+}>;
+export type LocalSource = Reference.LocalSource;
+export declare const GitSource: import("effect/Schema").Struct<{
+    readonly type: import("effect/Schema").Literal<"git">;
+    readonly repository: import("effect/Schema").String;
+    readonly branch: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").String>>, import("effect/Schema").optionalKey<import("effect/Schema").String>, never, never>;
+    readonly description: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").String>>, import("effect/Schema").optionalKey<import("effect/Schema").String>, never, never>;
+    readonly hidden: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Boolean>>, import("effect/Schema").optionalKey<import("effect/Schema").Boolean>, never, never>;
+}>;
+export type GitSource = Reference.GitSource;
+export declare const Source: import("effect/Schema").Union<readonly [import("effect/Schema").Struct<{
+    readonly type: import("effect/Schema").Literal<"local">;
+    readonly path: import("effect/Schema").brand<import("effect/Schema").String, "AbsolutePath">;
+    readonly description: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").String>>, import("effect/Schema").optionalKey<import("effect/Schema").String>, never, never>;
+    readonly hidden: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Boolean>>, import("effect/Schema").optionalKey<import("effect/Schema").Boolean>, never, never>;
+}>, import("effect/Schema").Struct<{
+    readonly type: import("effect/Schema").Literal<"git">;
+    readonly repository: import("effect/Schema").String;
+    readonly branch: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").String>>, import("effect/Schema").optionalKey<import("effect/Schema").String>, never, never>;
+    readonly description: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").String>>, import("effect/Schema").optionalKey<import("effect/Schema").String>, never, never>;
+    readonly hidden: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Boolean>>, import("effect/Schema").optionalKey<import("effect/Schema").Boolean>, never, never>;
+}>]>;
+export type Source = Reference.Source;
+export { Event } from "@opencode-ai/schema/reference";
+export declare const Info: import("effect/Schema").Struct<{
+    readonly name: import("effect/Schema").String;
+    readonly path: import("effect/Schema").brand<import("effect/Schema").String, "AbsolutePath">;
+    readonly description: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").String>>, import("effect/Schema").optionalKey<import("effect/Schema").String>, never, never>;
+    readonly hidden: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Boolean>>, import("effect/Schema").optionalKey<import("effect/Schema").Boolean>, never, never>;
+    readonly source: import("effect/Schema").Union<readonly [import("effect/Schema").Struct<{
+        readonly type: import("effect/Schema").Literal<"local">;
+        readonly path: import("effect/Schema").brand<import("effect/Schema").String, "AbsolutePath">;
+        readonly description: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").String>>, import("effect/Schema").optionalKey<import("effect/Schema").String>, never, never>;
+        readonly hidden: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Boolean>>, import("effect/Schema").optionalKey<import("effect/Schema").Boolean>, never, never>;
+    }>, import("effect/Schema").Struct<{
+        readonly type: import("effect/Schema").Literal<"git">;
+        readonly repository: import("effect/Schema").String;
+        readonly branch: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").String>>, import("effect/Schema").optionalKey<import("effect/Schema").String>, never, never>;
+        readonly description: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").String>>, import("effect/Schema").optionalKey<import("effect/Schema").String>, never, never>;
+        readonly hidden: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Boolean>>, import("effect/Schema").optionalKey<import("effect/Schema").Boolean>, never, never>;
+    }>]>;
+}>;
+export type Info = Reference.Info;
+type Draft = {
+    add(name: string, source: Source): void;
+    remove(name: string): void;
+    list(): readonly [string, Source][];
+};
+export interface Interface extends State.Transformable<Draft> {
+    readonly list: () => Effect.Effect<Info[]>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@opencode/Reference", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const node: import("@opencode-ai/util/effect/layer-node").Node<Service, never, import("@opencode-ai/util/effect/layer-node").Tag<"location">>;

package/dist/types/repository-cache.d.ts

@@ -0,0 +1,71 @@
+import { Context, Effect, Schema } from "effect";
+import { Repository } from "./repository.js";
+export type Result = {
+    readonly repository: string;
+    readonly host: string;
+    readonly remote: string;
+    readonly localPath: string;
+    readonly status: "cached" | "cloned" | "refreshed";
+    readonly head?: string;
+    readonly branch?: string;
+};
+export type EnsureInput = {
+    readonly reference: Repository.RemoteReference;
+    readonly refresh?: boolean;
+    readonly branch?: string;
+};
+declare const InvalidBranchError_base: Schema.Class<InvalidBranchError, Schema.TaggedStruct<"RepositoryCacheInvalidBranchError", {
+    readonly branch: Schema.String;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class InvalidBranchError extends InvalidBranchError_base {
+}
+declare const CloneFailedError_base: Schema.Class<CloneFailedError, Schema.TaggedStruct<"RepositoryCacheCloneFailedError", {
+    readonly repository: Schema.String;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class CloneFailedError extends CloneFailedError_base {
+}
+declare const FetchFailedError_base: Schema.Class<FetchFailedError, Schema.TaggedStruct<"RepositoryCacheFetchFailedError", {
+    readonly repository: Schema.String;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class FetchFailedError extends FetchFailedError_base {
+}
+declare const CheckoutFailedError_base: Schema.Class<CheckoutFailedError, Schema.TaggedStruct<"RepositoryCacheCheckoutFailedError", {
+    readonly repository: Schema.String;
+    readonly branch: Schema.String;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class CheckoutFailedError extends CheckoutFailedError_base {
+}
+declare const ResetFailedError_base: Schema.Class<ResetFailedError, Schema.TaggedStruct<"RepositoryCacheResetFailedError", {
+    readonly repository: Schema.String;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class ResetFailedError extends ResetFailedError_base {
+}
+declare const LockFailedError_base: Schema.Class<LockFailedError, Schema.TaggedStruct<"RepositoryCacheLockFailedError", {
+    readonly localPath: Schema.String;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class LockFailedError extends LockFailedError_base {
+}
+declare const CacheOperationError_base: Schema.Class<CacheOperationError, Schema.TaggedStruct<"RepositoryCacheOperationError", {
+    readonly operation: Schema.String;
+    readonly path: Schema.String;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class CacheOperationError extends CacheOperationError_base {
+}
+export type Error = InvalidBranchError | CloneFailedError | FetchFailedError | CheckoutFailedError | ResetFailedError | LockFailedError | CacheOperationError;
+export interface Interface {
+    readonly ensure: (input: EnsureInput) => Effect.Effect<Result, Error>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@opencode/RepositoryCache", Interface>;
+export declare class Service extends Service_base {
+}
+export declare function isError(error: unknown): error is Error;
+export declare const validateBranch: (branch: string) => Effect.Effect<void, InvalidBranchError, never>;
+export declare const node: import("@opencode-ai/util/effect/layer-node").Node<Service, never, import("@opencode-ai/util/effect/layer-node").Tag<"global">>;
+export * as RepositoryCache from "./repository-cache.js";

package/dist/types/repository.d.ts

@@ -0,0 +1,50 @@
+import { Schema } from "effect";
+type BaseReference = {
+    readonly host: string;
+    readonly path: string;
+    readonly segments: string[];
+    readonly owner?: string;
+    readonly repo: string;
+    readonly remote: string;
+    readonly label: string;
+};
+export type RemoteReference = BaseReference & {
+    readonly protocol?: string;
+};
+export type FileReference = BaseReference & {
+    readonly host: "file";
+    readonly protocol: "file:";
+};
+export type Reference = RemoteReference | FileReference;
+declare const InvalidReferenceError_base: Schema.Class<InvalidReferenceError, Schema.TaggedStruct<"RepositoryInvalidReferenceError", {
+    readonly repository: Schema.String;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class InvalidReferenceError extends InvalidReferenceError_base {
+}
+declare const UnsupportedLocalRepositoryError_base: Schema.Class<UnsupportedLocalRepositoryError, Schema.TaggedStruct<"RepositoryUnsupportedLocalRepositoryError", {
+    readonly repository: Schema.String;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class UnsupportedLocalRepositoryError extends UnsupportedLocalRepositoryError_base {
+}
+declare const InvalidBranchError_base: Schema.Class<InvalidBranchError, Schema.TaggedStruct<"RepositoryInvalidBranchError", {
+    readonly branch: Schema.String;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class InvalidBranchError extends InvalidBranchError_base {
+}
+export declare function parse(input: string): Reference | undefined;
+export declare function parseRemote(input: string): RemoteReference;
+export declare function validateBranch(branch: string): void;
+export declare function isFile(reference: Reference): reference is FileReference;
+export declare function isRemote(reference: Reference): reference is RemoteReference;
+/**
+ * Checkouts are keyed by remote and branch: a branch-specific reference gets
+ * its own directory so branchless refreshes can never move it. The branch is
+ * percent-encoded because valid branch names may contain `/`.
+ */
+export declare function cachePath(root: string, reference: Reference, branch?: string): string;
+export declare function cacheIdentity(reference: Reference): string;
+export declare function same(left: Reference, right: Reference): boolean;
+export * as Repository from "./repository.js";

package/dist/types/ripgrep/binary.d.ts

@@ -0,0 +1,11 @@
+import { Context, Effect } from "effect";
+export declare namespace RipgrepBinary {
+    interface Interface {
+        readonly filepath: Effect.Effect<string, Error>;
+    }
+    const Service_base: Context.ServiceClass<Service, "@opencode/RipgrepBinary", Interface>;
+    export class Service extends Service_base {
+    }
+    export const node: import("@opencode-ai/util/effect/layer-node").Node<Service, never, import("@opencode-ai/util/effect/layer-node").Tag<"global">>;
+    export {};
+}

package/dist/types/ripgrep.d.ts

@@ -0,0 +1,50 @@
+export * as Ripgrep from "./ripgrep.js";
+import { Context, Effect, Schema } from "effect";
+import { Entry, Match } from "@opencode-ai/schema/filesystem";
+declare const Error_base: Schema.Class<Error, Schema.TaggedStruct<"Ripgrep.Error", {
+    readonly message: Schema.String;
+    readonly cause: Schema.optional<Schema.Defect>;
+}>, import("effect/Cause").YieldableError>;
+export declare class Error extends Error_base {
+}
+declare const InvalidPatternError_base: Schema.Class<InvalidPatternError, Schema.TaggedStruct<"Ripgrep.InvalidPatternError", {
+    readonly pattern: Schema.String;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class InvalidPatternError extends InvalidPatternError_base {
+}
+export interface FindInput {
+    readonly cwd: string;
+    readonly pattern: string;
+    readonly limit: number;
+    readonly exclude?: readonly string[];
+    readonly hidden?: boolean;
+    readonly follow?: boolean;
+    readonly signal?: AbortSignal;
+    readonly onEntry?: (entry: Entry) => Effect.Effect<void>;
+}
+export interface GlobInput {
+    readonly cwd: string;
+    readonly pattern: string;
+    readonly limit: number;
+    readonly hidden?: boolean;
+    readonly follow?: boolean;
+    readonly signal?: AbortSignal;
+}
+export interface GrepInput {
+    readonly cwd: string;
+    readonly pattern: string;
+    readonly file?: string;
+    readonly include?: string;
+    readonly limit: number;
+    readonly signal?: AbortSignal;
+}
+export interface Interface {
+    readonly find: (input: FindInput) => Effect.Effect<readonly Entry[], Error>;
+    readonly glob: (input: GlobInput) => Effect.Effect<readonly Entry[], Error>;
+    readonly grep: (input: GrepInput) => Effect.Effect<readonly Match[], Error | InvalidPatternError>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@opencode/Ripgrep", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const node: import("@opencode-ai/util/effect/layer-node").Node<Service, never, import("@opencode-ai/util/effect/layer-node").Tag<"location">>;

package/dist/types/schema.d.ts

@@ -0,0 +1,45 @@
+import { Schema } from "effect";
+import { AbsolutePath, DateTimeUtcFromMillis, NonNegativeInt, optional, PositiveInt, RelativePath, statics } from "@opencode-ai/schema/schema";
+export { AbsolutePath, DateTimeUtcFromMillis, NonNegativeInt, optional, PositiveInt, RelativePath, statics };
+/**
+ * Strip `readonly` from a nested type. Stand-in for `effect`'s `Types.DeepMutable`
+ * until `effect:core/x228my` ("Types.DeepMutable widens unknown to `{}`") lands.
+ *
+ * The upstream version falls through `unknown` into `{ -readonly [K in keyof T]: ... }`
+ * where `keyof unknown = never`, so `unknown` collapses to `{}`. This local
+ * version gates the object branch on `extends object` (which `unknown` does
+ * not) so `unknown` passes through untouched.
+ *
+ * Primitive bailout matches upstream — without it, branded strings like
+ * `string & Brand<"SessionID">` fall into the object branch and get their
+ * prototype methods walked.
+ *
+ * Tuple branch preserves readonly tuples (e.g. `ConfigPlugin.Spec`'s
+ * `readonly [string, Options]`); the general array branch would otherwise
+ * widen them to unbounded arrays.
+ */
+export type DeepMutable<T> = T extends string | number | boolean | bigint | symbol | Function ? T : T extends readonly [unknown, ...unknown[]] ? {
+    -readonly [K in keyof T]: DeepMutable<T[K]>;
+} : T extends readonly (infer U)[] ? DeepMutable<U>[] : T extends object ? {
+    -readonly [K in keyof T]: DeepMutable<T[K]>;
+} : T;
+/**
+ * Nominal wrapper for scalar types. The class itself is a valid schema —
+ * pass it directly to `Schema.decode`, `Schema.decodeEffect`, etc.
+ *
+ * The runtime value remains an unwrapped primitive. `Schema.brand` supplies
+ * the primitive schema behavior and constructor validation, while the class
+ * supplies the nominal TypeScript identity.
+ * Apply checks and annotations to the underlying schema before wrapping it;
+ * schema rebuild operations intentionally return the underlying schema shape.
+ *
+ * @example
+ *   class QuestionID extends Newtype<QuestionID>()("QuestionID", Schema.String) {}
+ *
+ *   const id = QuestionID.make("question-1")
+ *   Schema.decodeUnknownEffect(QuestionID)(input)
+ */
+type NewtypeSchema<Self, Tag extends string, S extends Schema.Top> = (abstract new (_: never) => {
+    readonly _newtype: Tag;
+}) & Schema.Bottom<Self, S["Encoded"], S["DecodingServices"], S["EncodingServices"], S["ast"], S["Rebuild"], S["~type.make.in"], Self, S["~type.parameters"], Self, S["~type.mutability"], S["~type.optionality"], S["~type.constructor.default"], S["~encoded.mutability"], S["~encoded.optionality"]> & Omit<S, keyof Schema.Top>;
+export declare function Newtype<Self>(): <const Tag extends string, S extends Schema.Top>(tag: Tag, schema: S) => NewtypeSchema<Self, Tag, S>;

package/dist/types/session/compaction.d.ts

@@ -0,0 +1,39 @@
+export * as SessionCompaction from "./compaction.js";
+import { type LanguageModel } from "@opencode-ai/ai";
+import { Context, Effect, Layer } from "effect";
+import { Config } from "../config.js";
+import { Bus } from "../bus.js";
+import type { SessionMessage } from "./message.js";
+import { SessionRunnerModel } from "./runner/model.js";
+import { SessionSchema } from "./schema.js";
+import type { Info, Ref } from "../model.js";
+import { PluginHooks } from "../plugin/hooks.js";
+export type AutoInput = {
+    readonly session: SessionSchema.Info;
+    readonly messages: readonly SessionMessage.Info[];
+    readonly model: LanguageModel;
+    readonly ref: Ref;
+    readonly cost: Info["cost"];
+};
+export type ManualInput = {
+    readonly session: SessionSchema.Info;
+    readonly messages: readonly SessionMessage.Info[];
+    readonly inputID: SessionMessage.ID;
+};
+type RequiredInput = Omit<AutoInput, "ref">;
+export type Outcome = Pick<SessionMessage.CompactionCompleted, "status"> | Pick<SessionMessage.CompactionFailed, "status" | "error">;
+export interface Interface {
+    readonly required: (input: RequiredInput) => boolean;
+    readonly compact: (input: AutoInput) => Effect.Effect<Outcome>;
+    readonly compactManual: (input: ManualInput) => Effect.Effect<Outcome>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@opencode/SessionCompaction", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const serializeToolContent: (content: SessionMessage.ToolStateCompleted["content"]) => string;
+export declare const buildPrompt: (input: {
+    readonly previousSummary?: string;
+    readonly context: readonly string[];
+}) => string;
+export declare const layer: Layer.Layer<Service, never, Bus.Service | import("@opencode-ai/ai").LLMClientService | Config.Service | SessionRunnerModel.Service | PluginHooks.Service>;
+export declare const node: import("@opencode-ai/util/effect/layer-node").Node<Service, never, import("@opencode-ai/util/effect/layer-node").Tag<"location">>;

package/dist/types/session/context.d.ts

@@ -0,0 +1,44 @@
+export * as SessionContext from "./context.js";
+import { Context, Effect } from "effect";
+import { Agent } from "../agent.js";
+import { Instructions } from "../instructions/index.js";
+import { Tool } from "../tool.js";
+import { AgentNotFoundError } from "./error.js";
+import { SessionMessage } from "./message.js";
+import { SessionRunnerModel } from "./runner/model.js";
+import { SessionSchema } from "./schema.js";
+export interface Selection {
+    readonly session: SessionSchema.Info;
+    readonly agent: Agent.Selection & {
+        readonly info: Agent.Info;
+    };
+    readonly instructions: Instructions.List;
+    readonly tools: Tool.Snapshot;
+}
+export interface Loaded {
+    readonly session: SessionSchema.Info;
+    readonly agent: Agent.Selection & {
+        readonly info: Agent.Info;
+    };
+    readonly model: SessionRunnerModel.Resolved;
+    readonly initial: string;
+    readonly messages: ReadonlyArray<SessionMessage.Info>;
+    readonly tools: Tool.Snapshot;
+}
+/**
+ * Resolves model-request state in two phases: `select` fixes the Session,
+ * agent, instruction sources, and tool snapshot; `load` adds the model and
+ * active history for that selection. This module does not build or execute the
+ * model request.
+ */
+export interface Interface {
+    /** Selects the Session, agent, instructions, and tools used by subsequent work. */
+    readonly select: (sessionID: SessionSchema.ID) => Effect.Effect<Selection, AgentNotFoundError>;
+    /** Resolves the model and active history for that selection. */
+    readonly load: (selection: Selection) => Effect.Effect<Loaded, SessionRunnerModel.Error>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@opencode/SessionContext", Interface>;
+/** Location-scoped model-context loader for durable Session Steps. */
+export declare class Service extends Service_base {
+}
+export declare const node: import("@opencode-ai/util/effect/layer-node").Node<Service, never, import("@opencode-ai/util/effect/layer-node").Tag<"location">>;