@opencode/core 0.0.0-beta-19275

package/dist/types/pty.d.ts

@@ -0,0 +1,80 @@
+export * as Pty from "./pty.js";
+import { Context, Effect, Schema, Types } from "effect";
+import { PtyID } from "./pty/schema.js";
+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/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 node: import("@opencode/util/effect/layer-node").Provider<Service, never, import("@opencode/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/util/effect/layer-node").Provider<Service, never, import("@opencode/util/effect/layer-node").Tag<"location">>;

package/dist/types/reference.d.ts

@@ -0,0 +1,65 @@
+export * as Reference from "./reference.js";
+import { Context, Effect } from "effect";
+import { Reference } from "@opencode/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/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 Editor = {
+    add(name: string, source: Source): void;
+    remove(name: string): void;
+    list(): readonly [string, Source][];
+    get(name: string): Source | undefined;
+};
+export interface Interface extends State.Transformable<Editor> {
+    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/util/effect/layer-node").Provider<Service, never, import("@opencode/util/effect/layer-node").Tag<"location">>;

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

@@ -0,0 +1,72 @@
+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;
+    /** `daily` throttles existing checkouts; `true` forces a refresh. */
+    readonly refresh?: boolean | "daily";
+    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/util/effect/layer-node").Provider<Service, never, import("@opencode/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/util/effect/layer-node").Provider<Service, never, import("@opencode/util/effect/layer-node").Tag<"global">>;
+    export {};
+}

package/dist/types/ripgrep.d.ts

@@ -0,0 +1,52 @@
+export * as Ripgrep from "./ripgrep.js";
+import { Context, Effect, Schema } from "effect";
+import { Entry, Match } from "@opencode/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 literal?: boolean;
+    readonly caseSensitive?: boolean;
+    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/util/effect/layer-node").Provider<Service, never, import("@opencode/util/effect/layer-node").Tag<"location">>;

package/dist/types/rpc.d.ts

@@ -0,0 +1,15 @@
+export * as Rpc from "./rpc.js";
+export { define } from "@opencode/schema/rpc";
+export type { Definition, EventPayload, Failure } from "@opencode/schema/rpc";
+import type { RpcClient, RpcDomain } from "@opencode/plugin/effect/rpc";
+import type { Rpc } from "@opencode/schema/rpc";
+import { Context, Effect } from "effect";
+export interface Interface {
+    readonly register: RpcDomain["register"];
+    readonly client: <D extends Rpc.Definition>(definition: D) => RpcClient<D, Rpc.SystemError, never, unknown>;
+    readonly call: (rpcID: string, method: string, input: unknown) => Effect.Effect<unknown, Rpc.Failure>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@opencode/Rpc", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const node: import("@opencode/util/effect/layer-node").Provider<Service, never, import("@opencode/util/effect/layer-node").Tag<"location">>;

package/dist/types/schema.d.ts

@@ -0,0 +1,45 @@
+import { Schema } from "effect";
+import { AbsolutePath, DateTimeUtcFromMillis, NonNegativeInt, optional, PositiveInt, RelativePath, statics } from "@opencode/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.decodeUnknownSync`, `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.BottomWithoutNew<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/command.d.ts

@@ -0,0 +1,16 @@
+export * as SessionCommand from "./command.js";
+import type { PromptInput } from "@opencode/schema/prompt-input";
+import type { Session } from "@opencode/schema/session";
+import type { SessionInbox } from "@opencode/schema/session-inbox";
+import { Effect } from "effect";
+import { Command } from "../command.js";
+import { Instance } from "../instance/service.js";
+export declare const execute: (input: {
+    session: Session.Info;
+    command: string;
+    text: string;
+    files?: PromptInput.Prompt["files"];
+    agents?: PromptInput.Prompt["agents"];
+    skills?: PromptInput.Prompt["skills"];
+    delivery?: SessionInbox.Delivery;
+}) => Effect.Effect<void, Command.NotFoundError | Command.ExecutionError, Instance.Service>;

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

@@ -0,0 +1,64 @@
+export * as SessionCompaction from "./compaction.js";
+import { Message } from "@opencode/ai";
+import { Context, Effect, Layer } from "effect";
+import { Bus } from "../bus.js";
+import { Database } from "../database/database.js";
+import type { SessionContext } from "./context.js";
+import type { SessionMessage } from "./message.js";
+import { SessionModelRequest } from "./model-request.js";
+import type { SessionRunnerModel } from "./runner/model.js";
+import { SessionSchema } from "./schema.js";
+import { State } from "../state.js";
+import type { AgentNotFoundError } from "./error.js";
+import type { Instructions } from "../instructions/index.js";
+export type Settings = {
+    auto: boolean;
+    buffer: number;
+    tokens: number;
+};
+export type Editor = {
+    configure: (settings: Partial<Settings>) => void;
+};
+export type AutoInput = {
+    readonly context: SessionContext.Loaded;
+    readonly prepare: SessionModelRequest.Interface["prepare"];
+    /** Known overflow must recover from durable history, not submit the overflowing native window again. */
+    readonly overflow?: boolean;
+};
+type RequiredInput = {
+    readonly messages: readonly SessionMessage.Info[];
+    readonly resolved: SessionRunnerModel.Resolved;
+    readonly context: SessionContext.Loaded;
+};
+export type ManualInput = {
+    readonly session: SessionSchema.Info;
+    readonly messages: readonly SessionMessage.Info[];
+    readonly inputID: SessionMessage.ID;
+    readonly started?: boolean;
+    /** Empty compaction controls do not preflight model or instruction availability. */
+    readonly resolveContext: (session: SessionSchema.Info) => Effect.Effect<SessionContext.Loaded & {
+        readonly instructionUpdate: string;
+    }, SessionRunnerModel.Error | AgentNotFoundError | Instructions.InitializationBlocked>;
+    readonly prepare: SessionModelRequest.Interface["prepare"];
+};
+export type Outcome = (Pick<SessionMessage.CompactionCompleted, "status"> & {
+    /** Consumes the logical step's one overflow rebuild even when the native attempt overflowed first. */
+    readonly recoveredOverflow?: boolean;
+}) | Pick<SessionMessage.CompactionFailed, "status" | "error">;
+export interface Interface extends State.Transformable<Editor> {
+    readonly enabled: () => boolean;
+    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 estimateTokens: (input: RequiredInput) => number;
+/** Keep whole, real user messages, never synthetic guidance or half an attachment/tool exchange. */
+export declare const retainUsers: (messages: readonly SessionMessage.Info[], model: Pick<SessionRunnerModel.Resolved, "ref" | "capabilities">, keepTokens: number) => Message[];
+export declare const truncateToolOutput: (value: string) => string;
+export declare const serializeToolContent: (content: SessionMessage.ToolStateCompleted["content"]) => string;
+export declare const buildPrompt: (update: boolean) => string;
+export declare const layer: Layer.Layer<Service, never, Database.Service | Bus.Service | import("@opencode/ai").LLMClientService>;
+export declare const node: import("@opencode/util/effect/layer-node").Provider<Service, never, import("@opencode/util/effect/layer-node").Tag<"location">>;

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

@@ -0,0 +1,53 @@
+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 { SessionModelRequest } from "./model-request.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. Auxiliary operations resolve only the
+ * capabilities they need; request preparation stays separate from selection.
+ */
+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>;
+    readonly resolveModel: (session: SessionSchema.Info) => Effect.Effect<SessionRunnerModel.Resolved, SessionRunnerModel.Error>;
+    /** Selects auxiliary title capabilities without instruction or tool preflight. */
+    readonly selectTitle: (session: SessionSchema.Info) => Effect.Effect<{
+        readonly agent: Agent.Info;
+        readonly primary: SessionRunnerModel.Resolved | undefined;
+        readonly selected: SessionRunnerModel.Resolved;
+    } | undefined>;
+    readonly prepare: SessionModelRequest.Interface["prepare"];
+}
+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/util/effect/layer-node").Provider<Service, never, import("@opencode/util/effect/layer-node").Tag<"location">>;

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

@@ -0,0 +1,13 @@
+export * as SessionEnvironment from "./environment.js";
+import { Context, Effect } from "effect";
+import { SessionSchema } from "./schema.js";
+export type Variables = Readonly<Record<string, string>>;
+export interface Interface {
+    readonly get: (sessionID: SessionSchema.ID) => Effect.Effect<Variables | undefined>;
+    readonly set: (sessionID: SessionSchema.ID, variables: Variables) => Effect.Effect<void>;
+    readonly clear: (sessionID: SessionSchema.ID) => Effect.Effect<void>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@opencode/SessionEnvironment", 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">>;