@opencode/core 0.0.0-reserved → 2.0.1

package/dist/types/aisdk.d.ts

@@ -0,0 +1,52 @@
+export * as AISDK from "./aisdk.js";
+import type { LanguageModelV3 } from "@ai-sdk/provider";
+import { LanguageModel } from "@opencode/ai";
+import { Cause, Context, Effect, Layer, Schema, Scope } from "effect";
+import type { Info } from "./model.js";
+import { State } from "./state.js";
+type SDK = any;
+export interface SDKEvent {
+    readonly model: Info;
+    readonly package: string;
+    readonly options: Record<string, any>;
+    sdk?: SDK;
+}
+export interface LanguageEvent {
+    readonly model: Info;
+    readonly sdk: SDK;
+    readonly options: Record<string, any>;
+    language?: LanguageModelV3;
+}
+declare const InitError_base: Schema.Class<InitError, Schema.TaggedStruct<"AISDK.InitError", {
+    readonly providerID: Schema.brand<Schema.String, "Provider.ID"> & {
+        opencode: string & import("effect/Brand").Brand<"Provider.ID">;
+        anthropic: string & import("effect/Brand").Brand<"Provider.ID">;
+        openai: string & import("effect/Brand").Brand<"Provider.ID">;
+        google: string & import("effect/Brand").Brand<"Provider.ID">;
+        googleVertex: string & import("effect/Brand").Brand<"Provider.ID">;
+        githubCopilot: string & import("effect/Brand").Brand<"Provider.ID">;
+        amazonBedrock: string & import("effect/Brand").Brand<"Provider.ID">;
+        azure: string & import("effect/Brand").Brand<"Provider.ID">;
+        openrouter: string & import("effect/Brand").Brand<"Provider.ID">;
+        mistral: string & import("effect/Brand").Brand<"Provider.ID">;
+        gitlab: string & import("effect/Brand").Brand<"Provider.ID">;
+    };
+    readonly cause: Schema.Defect;
+}>, Cause.YieldableError>;
+export declare class InitError extends InitError_base {
+}
+export interface Interface {
+    readonly hook: {
+        readonly sdk: (callback: (event: SDKEvent) => Effect.Effect<void> | void) => Effect.Effect<State.Registration, never, Scope.Scope>;
+        readonly language: (callback: (event: LanguageEvent) => Effect.Effect<void> | void) => Effect.Effect<State.Registration, never, Scope.Scope>;
+    };
+    readonly runSDK: (event: SDKEvent) => Effect.Effect<SDKEvent>;
+    readonly runLanguage: (event: LanguageEvent) => Effect.Effect<LanguageEvent>;
+    readonly language: (model: Info) => Effect.Effect<LanguageModelV3, InitError>;
+    readonly model: (model: Info) => Effect.Effect<LanguageModel, InitError>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@opencode/AISDK", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const locationLayer: Layer.Layer<Service, never, never>;
+export declare const node: import("@opencode/util/effect/layer-node").Provider<Service, never, import("@opencode/util/effect/layer-node").Tag<"location">>;

package/dist/types/app.d.ts

@@ -0,0 +1,13 @@
+export * as App from "./app.js";
+import { Context, Layer } from "effect";
+export interface Info {
+    readonly name: string;
+    readonly version: string;
+    readonly channel: string;
+}
+export declare const Metadata: Context.Reference<Info>;
+export declare function make(input?: Partial<Info>): Info;
+export declare function useragent(app: Info): string;
+export declare const layer: (input?: Partial<Info>) => Layer.Layer<never, never, never>;
+export declare const configured: (input?: Partial<Info>) => import("@opencode/util/effect/layer-node").Provider<never, never, import("@opencode/util/effect/layer-node").Tag<"global">>;
+export declare const node: import("@opencode/util/effect/layer-node").Provider<never, never, import("@opencode/util/effect/layer-node").Tag<"global">>;

package/dist/types/bus.d.ts

@@ -0,0 +1,101 @@
+export * as Bus from "./bus.js";
+import { Cause, Context, Effect, Schema, Stream } from "effect";
+import { Event } from "@opencode/schema/event";
+import type { EventLog } from "@opencode/schema/event-log";
+import type { Location } from "@opencode/schema/location";
+export type Subscriber<D extends Event.Definition = Event.Definition> = (event: Event.Payload<D>) => Effect.Effect<void>;
+export type Unsubscribe = Effect.Effect<void>;
+export declare const latestSequence: (db: import("./database/drizzle.js").EffectSQLiteDatabase<import("drizzle-orm").EmptyRelations> & {
+    $client: import("effect/unstable/sql/SqlClient").SqlClient;
+}, aggregateID: string) => Effect.Effect<number, never, never>;
+export declare const reserveSequence: (db: import("./database/drizzle.js").EffectSQLiteDatabase<import("drizzle-orm").EmptyRelations> & {
+    $client: import("effect/unstable/sql/SqlClient").SqlClient;
+}, aggregateID: string, seq: number) => Effect.Effect<void, never, never>;
+export type SerializedEvent = {
+    readonly id: Event.ID;
+    readonly type: string;
+    readonly created?: number;
+    readonly seq: number;
+    readonly aggregateID: string;
+    readonly data: Record<string, unknown>;
+};
+declare const InvalidDurableEventError_base: Schema.Class<InvalidDurableEventError, Schema.TaggedStruct<"Bus.InvalidDurableEvent", {
+    readonly type: Schema.String;
+    readonly message: Schema.String;
+}>, Cause.YieldableError>;
+export declare class InvalidDurableEventError extends InvalidDurableEventError_base {
+}
+export declare const versionedType: typeof Event.versionedType;
+export declare const durable: typeof Event.durable;
+export declare const ephemeral: typeof Event.ephemeral;
+export interface PublishOptions {
+    readonly id?: Event.ID;
+    readonly metadata?: Record<string, unknown>;
+    readonly location?: Location.Ref;
+    readonly global?: boolean;
+    /** Local operational projection committed atomically with a new durable event. Not replayed or serialized. */
+    readonly commit?: (seq: number) => Effect.Effect<void>;
+}
+export type PublishInput<D extends Event.DurableDefinition = Event.DurableDefinition> = readonly [
+    definition: D,
+    data: Event.Data<D>,
+    options?: PublishOptions
+];
+export type PublishResult<I extends readonly PublishInput[]> = {
+    readonly [K in keyof I]: I[K] extends PublishInput<infer D> ? Event.Payload<D> : never;
+};
+/** Marker/event union emitted by `log`. */
+export type LogItem = Event.Payload | EventLog.Synced;
+export declare const isSynced: (item: LogItem) => item is EventLog.Synced;
+export type SubscribePayload<D extends readonly Event.Definition[]> = D[number] extends infer Item ? Item extends Event.Definition ? Event.Payload<Item> : never : never;
+export interface Subscribe {
+    /**
+     * Volatile live channel: every event published from now on, nothing before or
+     * across a disconnect. Consumers that need reliability combine it with `log`.
+     * With an ambient Location, delivery is restricted to that Location and global
+     * events. Unlocated Session events use the Session's owner at publication time.
+     * Session moves reach both the old and new Location, without changing the event.
+     */
+    (): Stream.Stream<Event.Payload>;
+    <D extends Event.Definition>(definition: D): Stream.Stream<Event.Payload<D>>;
+    <const D extends readonly [Event.Definition, ...Event.Definition[]]>(definitions: D): Stream.Stream<SubscribePayload<D>>;
+}
+export interface Interface {
+    readonly publish: <D extends Event.Definition>(definition: D, data: Event.Data<D>, options?: PublishOptions) => Effect.Effect<Event.Payload<D>>;
+    readonly publishAll: <const I extends readonly [PublishInput, ...PublishInput[]]>(events: I) => Effect.Effect<PublishResult<I>>;
+    readonly subscribe: Subscribe;
+    /**
+     * Durable, ordered per-aggregate log read. Forked aggregates may reserve an
+     * inherited prefix before their first child-authored event. `follow: false`
+     * completes at the end of the log; `follow: true` replays then transitions
+     * to live. Both modes emit one `Synced` marker at the captured replay
+     * watermark.
+     */
+    readonly log: (input: {
+        readonly aggregateID: string;
+        readonly after?: number;
+        readonly follow?: boolean;
+    }) => Stream.Stream<LogItem>;
+    /** @deprecated Use `subscribe()` and consume the returned stream. */
+    readonly listen: (listener: Subscriber) => Effect.Effect<Unsubscribe>;
+    readonly project: <D extends Event.Definition>(definition: D, projector: Subscriber<D>) => Effect.Effect<void>;
+    readonly replay: (event: SerializedEvent, options?: {
+        readonly publish?: boolean;
+        readonly ownerID?: string;
+        readonly strictOwner?: boolean;
+    }) => Effect.Effect<void>;
+    readonly remove: (aggregateID: string) => Effect.Effect<void>;
+    readonly claim: (aggregateID: string, ownerID: string) => Effect.Effect<void>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@opencode/Bus", Interface>;
+export declare class Service extends Service_base {
+}
+interface Options {
+    readonly beforeAggregateRead?: (aggregateID: string) => Effect.Effect<void>;
+    /** Maximum durable rows read per page while replaying or tailing an aggregate log. */
+    readonly logReadPageSize?: number;
+    /** Retain durable event payloads for historical log reads and replay. */
+    readonly persist?: boolean;
+}
+export declare function configured(options?: Options): import("@opencode/util/effect/layer-node").Provider<Service, never, import("@opencode/util/effect/layer-node").Tag<"global">>;
+export declare const node: import("@opencode/util/effect/layer-node").Provider<Service, never, import("@opencode/util/effect/layer-node").Tag<"global">>;

package/dist/types/catalog.d.ts

@@ -0,0 +1,49 @@
+export * as Catalog from "./catalog.js";
+import { Context, Effect } from "effect";
+import { Model } from "./model.js";
+import { Provider } from "./provider.js";
+import { State } from "./state.js";
+export type ProviderRecord = {
+    provider: Provider.MutableInfo;
+    models: Map<Model.ID, Model.MutableInfo>;
+};
+export type DefaultModel = {
+    providerID: Provider.ID;
+    modelID: Model.ID;
+};
+export { Event } from "@opencode/schema/catalog";
+export type Editor = {
+    provider: {
+        list: () => readonly ProviderRecord[];
+        get: (providerID: Provider.ID) => ProviderRecord | undefined;
+        update: (providerID: Provider.ID, fn: (provider: Provider.MutableInfo) => void) => void;
+        remove: (providerID: Provider.ID) => void;
+    };
+    model: {
+        get: (providerID: Provider.ID, modelID: Model.ID) => Model.Info | undefined;
+        update: (providerID: Provider.ID, modelID: Model.ID, fn: (model: Model.MutableInfo) => void) => void;
+        remove: (providerID: Provider.ID, modelID: Model.ID) => void;
+        default: {
+            get: () => DefaultModel | undefined;
+            set: (providerID: Provider.ID, modelID: Model.ID) => void;
+        };
+    };
+};
+export interface Interface extends State.Transformable<Editor> {
+    readonly provider: {
+        readonly get: (providerID: Provider.ID) => Effect.Effect<Provider.Info | undefined>;
+        readonly all: () => Effect.Effect<Provider.Info[]>;
+        readonly available: () => Effect.Effect<Provider.Info[]>;
+    };
+    readonly model: {
+        readonly get: (providerID: Provider.ID, modelID: Model.ID) => Effect.Effect<Model.Info | undefined>;
+        readonly all: () => Effect.Effect<Model.Info[]>;
+        readonly available: () => Effect.Effect<Model.Info[]>;
+        readonly default: () => Effect.Effect<Model.Info | undefined>;
+        readonly small: (providerID: Provider.ID) => Effect.Effect<Model.Info | undefined>;
+    };
+}
+declare const Service_base: Context.ServiceClass<Service, "@opencode/Catalog", 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/codemode/catalog.d.ts

@@ -0,0 +1,47 @@
+export * as CodeModeCatalog from "./catalog.js";
+import { Schema } from "effect";
+export declare const Tool: Schema.Struct<{
+    readonly type: Schema.Literal<"tool">;
+    readonly name: Schema.String;
+    readonly description: Schema.String;
+    readonly signature: Schema.String;
+    readonly pinned: Schema.optionalKey<Schema.Boolean>;
+}>;
+export type Tool = typeof Tool.Type;
+export type Namespace = {
+    readonly type: "namespace";
+    readonly name: string;
+    readonly description?: string;
+    readonly tools: ReadonlyArray<Tool | Namespace>;
+};
+export type Inventory = {
+    readonly tools: ReadonlyArray<Tool | Namespace>;
+};
+declare const NamespaceSummary: Schema.Struct<{
+    readonly name: Schema.String;
+    readonly description: Schema.optionalKey<Schema.String>;
+    readonly count: Schema.Number;
+    readonly entries: Schema.$Array<Schema.Struct<{
+        readonly path: Schema.String;
+        readonly line: Schema.String;
+    }>>;
+}>;
+export declare const Summary: Schema.Struct<{
+    readonly total: Schema.Number;
+    readonly shown: Schema.Number;
+    readonly namespaces: Schema.$Array<Schema.Struct<{
+        readonly name: Schema.String;
+        readonly description: Schema.optionalKey<Schema.String>;
+        readonly count: Schema.Number;
+        readonly entries: Schema.$Array<Schema.Struct<{
+            readonly path: Schema.String;
+            readonly line: Schema.String;
+        }>>;
+    }>>;
+}>;
+export type Summary = typeof Summary.Type;
+export type Options = {
+    readonly budget?: number;
+};
+export declare function summarize(inventory: Inventory, options?: Options): Summary;
+export declare function namespaceLine(namespace: typeof NamespaceSummary.Type): string;

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

@@ -0,0 +1,6 @@
+export * as CodeModeInstructions from "./instructions.js";
+import { Instructions } from "../instructions/index.js";
+import { CodeModeCatalog } from "./catalog.js";
+export declare function render(catalog: CodeModeCatalog.Summary): string;
+export declare function update(previous: CodeModeCatalog.Summary, current: CodeModeCatalog.Summary): string;
+export declare const make: (inventory?: CodeModeCatalog.Inventory) => Instructions.List;

package/dist/types/codemode/tool.d.ts

@@ -0,0 +1,66 @@
+export * as CodeModeTool from "./tool.js";
+import type { Context, Error, Info, Namespace as ToolNamespace, Result } from "@opencode/schema/tool";
+import { Effect, Schema } from "effect";
+import { CodeModeCatalog } from "./catalog.js";
+export type Inventory = {
+    readonly tools: ReadonlyMap<string, Info>;
+    readonly namespaces?: ReadonlyMap<string, ToolNamespace>;
+};
+export declare const create: (inventory: Inventory, executeTool: (name: string, tool: Info, input: unknown, context: Context) => Effect.Effect<Result, Error>) => {
+    name: string;
+    description: string;
+    input: Schema.Struct<{
+        readonly code: Schema.String;
+    }>;
+    output: Schema.Struct<{
+        readonly output: Schema.String;
+        readonly toolCalls: Schema.$Array<Schema.Struct<{
+            readonly tool: Schema.String;
+            readonly status: Schema.Literals<readonly ["running", "completed", "error"]>;
+            readonly input: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+        }>>;
+        readonly error: Schema.optionalKey<Schema.Literal<true>>;
+        readonly files: Schema.$Array<Schema.Struct<{
+            readonly data: Schema.String;
+            readonly mime: Schema.String;
+            readonly name: Schema.optionalKey<Schema.String>;
+        }>>;
+    }>;
+    execute: ({ code }: any, context: Context) => Effect.Effect<{
+        output: {
+            readonly output: string;
+            readonly files: readonly {
+                readonly data: string;
+                readonly mime: string;
+                readonly name?: string | undefined;
+            }[];
+            readonly toolCalls: readonly {
+                readonly status: "error" | "running" | "completed";
+                readonly tool: string;
+                readonly input?: {
+                    readonly [x: string]: Schema.Json;
+                } | undefined;
+            }[];
+            readonly error?: true | undefined;
+        };
+        content: ({
+            readonly type: "text";
+            readonly text: string;
+        } | {
+            readonly type: "file";
+            readonly uri: string;
+            readonly mime: string;
+            readonly name?: string | undefined;
+        })[];
+        metadata: Readonly<Record<string, any>>;
+    }, never, never>;
+};
+export declare const catalog: (inventory: Inventory) => {
+    tools: readonly ({
+        readonly name: string;
+        readonly description: string;
+        readonly type: "tool";
+        readonly signature: string;
+        readonly pinned?: boolean | undefined;
+    } | CodeModeCatalog.Namespace)[];
+};

package/dist/types/command.d.ts

@@ -0,0 +1,52 @@
+export * as Command from "./command.js";
+import { Command } from "@opencode/schema/command";
+import type { PromptInput } from "@opencode/schema/prompt-input";
+import type { Session } from "@opencode/schema/session";
+import type { SessionInbox } from "@opencode/schema/session-inbox";
+import { Context, Effect, Layer, Schema } from "effect";
+import { Bus } from "./bus.js";
+import { State } from "./state.js";
+export declare const Info: Schema.Struct<{
+    readonly name: Schema.String;
+    readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+}>;
+export type Info = Command.Info;
+export { Event } from "@opencode/schema/command";
+export interface Invocation {
+    readonly sessionID: Session.ID;
+    readonly prompt: PromptInput.Prompt;
+    readonly delivery: SessionInbox.Delivery;
+}
+export interface Definition {
+    readonly name: string;
+    readonly description?: string;
+    readonly execute: (input: Invocation) => Effect.Effect<void, unknown>;
+}
+export type Editor = {
+    add: (definition: Definition) => void;
+};
+declare const NotFoundError_base: Schema.Class<NotFoundError, Schema.TaggedStruct<"Command.NotFoundError", {
+    readonly command: Schema.String;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class NotFoundError extends NotFoundError_base {
+}
+declare const ExecutionError_base: Schema.Class<ExecutionError, Schema.TaggedStruct<"Command.ExecutionError", {
+    readonly command: Schema.String;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class ExecutionError extends ExecutionError_base {
+}
+export interface Interface extends State.Transformable<Editor> {
+    readonly get: (name: string) => Effect.Effect<Info | undefined>;
+    readonly list: () => Effect.Effect<Info[]>;
+    readonly execute: (input: {
+        readonly name: string;
+        readonly invocation: Invocation;
+    }) => Effect.Effect<void, NotFoundError | ExecutionError>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@opencode/Command", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const layer: Layer.Layer<Service, never, Bus.Service>;
+export declare const node: import("@opencode/util/effect/layer-node").Provider<Service, never, import("@opencode/util/effect/layer-node").Tag<"location">>;

package/dist/types/config/discovery.d.ts

@@ -0,0 +1,35 @@
+export * as ConfigDiscovery from "./discovery.js";
+import { Effect } from "effect";
+import { FSUtil } from "@opencode/util/fs-util";
+import { Global } from "@opencode/util/global";
+import { Location } from "../location.js";
+import { AbsolutePath } from "../schema.js";
+export declare const names: string[];
+/** Eligible sources in priority order, including paths that may appear later. */
+export interface Sources {
+    readonly global?: AbsolutePath;
+    readonly explicit?: AbsolutePath;
+    readonly direct: readonly AbsolutePath[];
+    readonly project: readonly {
+        readonly path: AbsolutePath;
+        readonly present: boolean;
+    }[];
+    readonly claude: readonly AbsolutePath[];
+    readonly agents: readonly AbsolutePath[];
+}
+export declare const discover: (options?: {
+    readonly global?: boolean | undefined;
+    readonly project?: boolean | undefined;
+    readonly file?: string | undefined;
+    readonly content?: string | undefined;
+} | undefined) => Effect.Effect<{
+    global: (string & import("effect/Brand").Brand<"AbsolutePath">) | undefined;
+    explicit: (string & import("effect/Brand").Brand<"AbsolutePath">) | undefined;
+    direct: (string & import("effect/Brand").Brand<"AbsolutePath">)[];
+    project: {
+        path: string & import("effect/Brand").Brand<"AbsolutePath">;
+        present: boolean;
+    }[];
+    claude: (string & import("effect/Brand").Brand<"AbsolutePath">)[];
+    agents: (string & import("effect/Brand").Brand<"AbsolutePath">)[];
+}, never, Global.Service | FSUtil.Service | Location.Service>;

package/dist/types/config/markdown.d.ts

@@ -0,0 +1,5 @@
+export * as ConfigMarkdown from "./markdown.js";
+import matter from "gray-matter";
+export declare function parse(content: string): matter.GrayMatterFile<string>;
+export declare function parseOption(content: string): matter.GrayMatterFile<string> | undefined;
+export declare function sanitize(content: string): string;

package/dist/types/config/normalize.d.ts

@@ -0,0 +1,15 @@
+export * as ConfigNormalize from "./normalize.js";
+export interface Diagnostic {
+    readonly kind: "conflict" | "invalid" | "unsupported";
+    readonly path: readonly string[];
+    readonly message: string;
+}
+export type Result = {
+    readonly type: "normalized";
+    readonly encoded: Readonly<Record<string, unknown>>;
+    readonly diagnostics: readonly Diagnostic[];
+} | {
+    readonly type: "rejected";
+    readonly diagnostics: readonly Diagnostic[];
+};
+export declare function normalize(input: unknown): Result;

package/dist/types/config/plugin/agent.d.ts

@@ -0,0 +1,5 @@
+export * as ConfigAgentPlugin from "./agent.js";
+import { Config } from "../../config.js";
+import { FSUtil } from "@opencode/util/fs-util";
+import { Global } from "@opencode/util/global";
+export declare const Plugin: import("@opencode/plugin/effect/plugin").Plugin<import("effect/Scope").Scope | Global.Service | FSUtil.Service | Config.Service>;

package/dist/types/config/plugin/command.d.ts

@@ -0,0 +1,9 @@
+export * as ConfigCommandPlugin from "./command.js";
+import { AppProcess } from "@opencode/util/process";
+import { Agent } from "../../agent.js";
+import { Config } from "../../config.js";
+import { Location } from "../../location.js";
+import { Session } from "../../session.js";
+import { ShellSelect } from "../../shell/select.js";
+import { FSUtil } from "@opencode/util/fs-util";
+export declare const Plugin: import("@opencode/plugin/effect/plugin").Plugin<import("effect/Scope").Scope | FSUtil.Service | AppProcess.Service | Location.Service | Agent.Service | Config.Service | ShellSelect.Service | Session.Service | import("../../job.js").Service>;

package/dist/types/config/plugin/compaction.d.ts

@@ -0,0 +1,4 @@
+export * as ConfigCompactionPlugin from "./compaction.js";
+import { Config } from "../../config.js";
+import { SessionCompaction } from "../../session/compaction.js";
+export declare const Plugin: import("@opencode/plugin/effect/plugin").Plugin<import("effect/Scope").Scope | Config.Service | SessionCompaction.Service>;

package/dist/types/config/plugin/entry-observer.d.ts

@@ -0,0 +1,7 @@
+export * as ConfigEntryObserver from "./entry-observer.js";
+import type { EventDomain } from "@opencode/plugin/effect/event";
+import { Effect } from "effect";
+import { Config } from "../../config.js";
+export declare const observe: (config: Config.Interface, event: EventDomain, reload: Effect.Effect<void, never, never>) => Effect.Effect<{
+    entries: (import("@opencode/schema/config").Document | import("@opencode/schema/config").Directory | import("@opencode/schema/config").AgentsDirectory | import("@opencode/schema/config").ClaudeDirectory)[];
+}, never, import("effect/Scope").Scope>;

package/dist/types/config/plugin/formatter.d.ts

@@ -0,0 +1,9 @@
+export * as ConfigFormatterPlugin from "./formatter.js";
+import { FSUtil } from "@opencode/util/fs-util";
+import { Global } from "@opencode/util/global";
+import { Npm } from "@opencode/util/npm";
+import { AppProcess } from "@opencode/util/process";
+import { Config } from "../../config.js";
+import { Formatter } from "../../formatter.js";
+import { Location } from "../../location.js";
+export declare const Plugin: import("@opencode/plugin/effect/plugin").Plugin<import("effect/Scope").Scope | Global.Service | FSUtil.Service | AppProcess.Service | Location.Service | Npm.Service | Config.Service | Formatter.Service>;

package/dist/types/config/plugin/image.d.ts

@@ -0,0 +1,4 @@
+export * as ConfigImagePlugin from "./image.js";
+import { Config } from "../../config.js";
+import { Image } from "../../image.js";
+export declare const Plugin: import("@opencode/plugin/effect/plugin").Plugin<import("effect/Scope").Scope | Config.Service | Image.Service>;

package/dist/types/config/plugin/instruction.d.ts

@@ -0,0 +1,7 @@
+export * as ConfigInstructionPlugin from "./instruction.js";
+import { FSUtil } from "@opencode/util/fs-util";
+import { Global } from "@opencode/util/global";
+import { Watcher } from "../../filesystem/watcher.js";
+import { InstructionDiscovery } from "../../instruction-discovery.js";
+import { Location } from "../../location.js";
+export declare const Plugin: import("@opencode/plugin/effect/plugin").Plugin<import("effect/Scope").Scope | Global.Service | FSUtil.Service | Location.Service | Watcher.Service | InstructionDiscovery.Service>;

package/dist/types/config/plugin/location-watcher.d.ts

@@ -0,0 +1,4 @@
+export * as ConfigLocationWatcherPlugin from "./location-watcher.js";
+import { Config } from "../../config.js";
+import { LocationWatcherPolicy } from "../../filesystem/location-watcher-policy.js";
+export declare const Plugin: import("@opencode/plugin/effect/plugin").Plugin<import("effect/Scope").Scope | Config.Service | LocationWatcherPolicy.Service>;

package/dist/types/config/plugin/mcp.d.ts

@@ -0,0 +1,8 @@
+export * as ConfigMcpPlugin from "./mcp.js";
+import { Effect, Stream } from "effect";
+import { Config } from "../../config.js";
+import { Mcp } from "../../mcp/index.js";
+export declare const Plugin: import("@opencode/plugin/effect/plugin").Plugin<import("effect/Scope").Scope | Config.Service | Mcp.Service>;
+export declare const register: (events: Stream.Stream<{
+    readonly type: string;
+}, unknown, never>) => Effect.Effect<void, never, import("effect/Scope").Scope | Config.Service | Mcp.Service>;

package/dist/types/config/plugin/policy.d.ts

@@ -0,0 +1,3 @@
+export * as ConfigPolicyPlugin from "./policy.js";
+import { Config } from "../../config.js";
+export declare const Plugin: import("@opencode/plugin/effect/plugin").Plugin<import("effect/Scope").Scope | Config.Service>;

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

@@ -0,0 +1,3 @@
+export * as ConfigProviderPlugin from "./provider.js";
+import { Config } from "../../config.js";
+export declare const Plugin: import("@opencode/plugin/effect/plugin").Plugin<import("effect/Scope").Scope | Config.Service>;

package/dist/types/config/plugin/reference.d.ts

@@ -0,0 +1,5 @@
+export * as ConfigReferencePlugin from "./reference.js";
+import { Config } from "../../config.js";
+import { Global } from "@opencode/util/global";
+import { Location } from "../../location.js";
+export declare const Plugin: import("@opencode/plugin/effect/plugin").Plugin<import("effect/Scope").Scope | Global.Service | Location.Service | Config.Service>;

package/dist/types/config/plugin/shell.d.ts

@@ -0,0 +1,4 @@
+export * as ConfigShellPlugin from "./shell.js";
+import { Config } from "../../config.js";
+import { ShellSelect } from "../../shell/select.js";
+export declare const Plugin: import("@opencode/plugin/effect/plugin").Plugin<import("effect/Scope").Scope | Config.Service | ShellSelect.Service>;

package/dist/types/config/plugin/skill-file.d.ts

@@ -0,0 +1,15 @@
+export * as SkillFile from "./skill-file.js";
+import { type SchemaIssue } from "effect";
+import { Skill } from "../../skill.js";
+export type ParseResult = {
+    readonly _tag: "Parsed";
+    readonly skill: Skill.Info;
+} | {
+    readonly _tag: "Skipped";
+    readonly reason: "markdown";
+} | {
+    readonly _tag: "Skipped";
+    readonly reason: "frontmatter";
+    readonly issue: SchemaIssue.Issue;
+};
+export declare function parse(directory: string, filepath: string, content: string): ParseResult;

package/dist/types/config/plugin/skill.d.ts

@@ -0,0 +1,8 @@
+export * as ConfigSkillPlugin from "./skill.js";
+import { FSUtil } from "@opencode/util/fs-util";
+import { Global } from "@opencode/util/global";
+import { Config } from "../../config.js";
+import { Watcher } from "../../filesystem/watcher.js";
+import { Location } from "../../location.js";
+import { SkillDiscovery } from "../../skill/discovery.js";
+export declare const Plugin: import("@opencode/plugin/effect/plugin").Plugin<import("effect/Scope").Scope | Global.Service | FSUtil.Service | Location.Service | Watcher.Service | Config.Service | SkillDiscovery.Service>;

package/dist/types/config/plugin/snapshot.d.ts

@@ -0,0 +1,4 @@
+export * as ConfigSnapshotPlugin from "./snapshot.js";
+import { Config } from "../../config.js";
+import { Snapshot } from "../../snapshot.js";
+export declare const Plugin: import("@opencode/plugin/effect/plugin").Plugin<import("effect/Scope").Scope | Config.Service | Snapshot.Service>;

package/dist/types/config/plugin/source.d.ts

@@ -0,0 +1,25 @@
+export * as ConfigPluginSource from "./source.js";
+import { FSUtil } from "@opencode/util/fs-util";
+import { Context, Effect, Layer, Scope, Stream } from "effect";
+import { Config } from "../../config.js";
+import { Watcher } from "../../filesystem/watcher.js";
+import { Location } from "../../location.js";
+export type Operation = {
+    readonly type: "add";
+    readonly target: string;
+    readonly options: Record<string, unknown>;
+    readonly mtime?: number;
+} | {
+    readonly type: "remove";
+    readonly target: string;
+};
+export interface Interface {
+    readonly operations: () => Effect.Effect<readonly Operation[], never, Scope.Scope>;
+    readonly changes: () => Stream.Stream<void>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@opencode/ConfigPluginSource", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const layer: Layer.Layer<Service, never, FSUtil.Service | Location.Service | Watcher.Service | Config.Service>;
+export declare const node: import("@opencode/util/effect/layer-node").Provider<Service, never, import("@opencode/util/effect/layer-node").Tag<"location">>;
+export declare const empty: import("@opencode/util/effect/layer-node").Provider<Service, never, import("@opencode/util/effect/layer-node").Tag<"location">>;

package/dist/types/config/plugin/tool-output.d.ts

@@ -0,0 +1,4 @@
+export * as ConfigToolOutputPlugin from "./tool-output.js";
+import { Config } from "../../config.js";
+import { ToolOutput } from "../../tool-output.js";
+export declare const Plugin: import("@opencode/plugin/effect/plugin").Plugin<import("effect/Scope").Scope | Config.Service | ToolOutput.Service>;

package/dist/types/config/plugin/websearch.d.ts

@@ -0,0 +1,3 @@
+export * as ConfigWebSearchPlugin from "./websearch.js";
+import { Config } from "../../config.js";
+export declare const Plugin: import("@opencode/plugin/effect/plugin").Plugin<import("effect/Scope").Scope | Config.Service>;

package/dist/types/config/plugin/worktree.d.ts

@@ -0,0 +1,6 @@
+export * as ConfigWorktreePlugin from "./worktree.js";
+import { Config } from "../../config.js";
+import { Global } from "@opencode/util/global";
+import { Location } from "../../location.js";
+import { Worktree } from "../../worktree.js";
+export declare const Plugin: import("@opencode/plugin/effect/plugin").Plugin<import("effect/Scope").Scope | Global.Service | Location.Service | Config.Service | Worktree.Service>;