@opencode-ai/core 0.0.0-dev-17471

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

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

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-ai/schema/pty";

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

@@ -0,0 +1,24 @@
+export * as PtyTicket from "./ticket.js";
+import { Workspace } from "../workspace.js";
+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-ai/util/effect/layer-node").Node<Service, never, import("@opencode-ai/util/effect/layer-node").Tag<"global">>;

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 | Bus.Service | Location.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/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,40 @@
+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;
+    readonly started?: boolean;
+};
+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">>;

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

@@ -0,0 +1,56 @@
+export * as SessionErrors from "./error.js";
+import { Schema } from "effect";
+declare const NotFoundError_base: Schema.Class<NotFoundError, Schema.TaggedStruct<"Session.NotFoundError", {
+    readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
+        create: () => string & import("effect/Brand").Brand<"SessionID">;
+        descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+    };
+}>, import("effect/Cause").YieldableError>;
+export declare class NotFoundError extends NotFoundError_base {
+}
+declare const ForkEmptyError_base: Schema.Class<ForkEmptyError, Schema.TaggedStruct<"Session.ForkEmptyError", {
+    readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
+        create: () => string & import("effect/Brand").Brand<"SessionID">;
+        descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+    };
+}>, import("effect/Cause").YieldableError>;
+export declare class ForkEmptyError extends ForkEmptyError_base {
+    get message(): string;
+}
+declare const MessageDecodeError_base: Schema.Class<MessageDecodeError, Schema.TaggedStruct<"Session.MessageDecodeError", {
+    readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
+        create: () => string & import("effect/Brand").Brand<"SessionID">;
+        descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+    };
+    readonly messageID: Schema.brand<Schema.String, "Session.Message.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
+        fromEvent: (eventID: import("@opencode-ai/schema/event").ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
+    };
+}>, import("effect/Cause").YieldableError>;
+export declare class MessageDecodeError extends MessageDecodeError_base {
+    get message(): string;
+}
+declare const AgentNotFoundError_base: Schema.Class<AgentNotFoundError, Schema.TaggedStruct<"Session.AgentNotFoundError", {
+    readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
+        create: () => string & import("effect/Brand").Brand<"SessionID">;
+        descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+    };
+    readonly agent: Schema.brand<Schema.String, "Agent.ID">;
+}>, import("effect/Cause").YieldableError>;
+export declare class AgentNotFoundError extends AgentNotFoundError_base {
+    get message(): string;
+}
+declare const StepFailedError_base: Schema.Class<StepFailedError, Schema.TaggedStruct<"Session.StepFailedError", {
+    readonly error: Schema.Struct<{
+        readonly type: Schema.String;
+        readonly message: Schema.String;
+        readonly status: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+    }>;
+}>, import("effect/Cause").YieldableError>;
+export declare class StepFailedError extends StepFailedError_base {
+    get message(): string;
+}
+declare const UserInterruptedError_base: Schema.Class<UserInterruptedError, Schema.TaggedStruct<"Session.UserInterruptedError", {}>, import("effect/Cause").YieldableError>;
+export declare class UserInterruptedError extends UserInterruptedError_base {
+    get message(): string;
+}

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

@@ -0,0 +1,2 @@
+export * from "@opencode-ai/schema/session-event";
+export * as SessionEvent from "@opencode-ai/schema/session-event";

package/dist/types/session/execution/restart.d.ts

@@ -0,0 +1,43 @@
+export * as SessionRestart from "./restart.js";
+import { Context, Effect, Layer } from "effect";
+import { Bus } from "../../bus.js";
+import { SessionExecution } from "../execution.js";
+import { SessionStore } from "../store.js";
+export interface Options {
+    /**
+     * Times a single turn may be resumed before it is terminalized instead.
+     * The counter is durable and only a terminal event resets it, so a turn
+     * that keeps dying cannot crash-loop across restarts. Turns that complete
+     * never accumulate: the budget is per-turn, not per-session.
+     */
+    readonly maxAttempts?: number;
+}
+export interface Interface {
+    /**
+     * Resumes Sessions whose execution claim was never released — turns orphaned
+     * by a process that died without teardown, or interrupted by a graceful
+     * shutdown (which preserves the claim on purpose). The claim is never
+     * cleared here: only a terminal event releases it, so a death anywhere in
+     * the resume path leaves the same orphaned claim for the next boot.
+     */
+    readonly resumeSuspendedSessions: Effect.Effect<void>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@opencode/SessionRestart", Interface>;
+/**
+ * Recovery for orphaned executions. Claims are written at turn start by
+ * SessionExecution, so this sweep needs no cooperation from the previous
+ * process: crash, SIGKILL, isolate eviction, and graceful restart all leave
+ * the same durable signature.
+ *
+ * The sweep assumes every orphaned claim's owner is dead. The managed-server
+ * protocol guarantees this: a successor is only spawned after the previous
+ * process is confirmed dead (client service `kill`/`evict` poll the PID), the
+ * registration lock admits one managed server at a time, and unregistered
+ * servers sharing the database never sweep. The service is inert until called
+ * — the managed server invokes it at boot; embedders may call it from their
+ * own start-up.
+ */
+export declare class Service extends Service_base {
+}
+export declare const layer: (options?: Options) => Layer.Layer<Service, never, Bus.Service | SessionStore.Service | SessionExecution.Service>;
+export declare const node: import("@opencode-ai/util/effect/layer-node").Node<Service, never, import("@opencode-ai/util/effect/layer-node").Tag<"global">>;