@opencode-ai/core 0.0.0-beta-17498

package/dist/types/database/path.d.ts

@@ -0,0 +1,68 @@
+export declare const absoluteColumn: {
+    (): import("drizzle-orm/sqlite-core").SQLiteCustomColumnBuilder<{
+        dataType: "custom";
+        data: string & import("effect/Brand").Brand<"AbsolutePath">;
+        driverParam: string;
+    }>;
+    <TConfig extends Record<string, any>>(fieldConfig?: TConfig | undefined): import("drizzle-orm/sqlite-core").SQLiteCustomColumnBuilder<{
+        dataType: "custom";
+        data: string & import("effect/Brand").Brand<"AbsolutePath">;
+        driverParam: string;
+    }>;
+    (dbname: string, fieldConfig?: unknown): import("drizzle-orm/sqlite-core").SQLiteCustomColumnBuilder<{
+        dataType: "custom";
+        data: string & import("effect/Brand").Brand<"AbsolutePath">;
+        driverParam: string;
+    }>;
+};
+export declare const directoryColumn: {
+    (): import("drizzle-orm/sqlite-core").SQLiteCustomColumnBuilder<{
+        dataType: "custom";
+        data: string;
+        driverParam: string;
+    }>;
+    <TConfig extends Record<string, any>>(fieldConfig?: TConfig | undefined): import("drizzle-orm/sqlite-core").SQLiteCustomColumnBuilder<{
+        dataType: "custom";
+        data: string;
+        driverParam: string;
+    }>;
+    (dbname: string, fieldConfig?: unknown): import("drizzle-orm/sqlite-core").SQLiteCustomColumnBuilder<{
+        dataType: "custom";
+        data: string;
+        driverParam: string;
+    }>;
+};
+export declare const pathColumn: {
+    (): import("drizzle-orm/sqlite-core").SQLiteCustomColumnBuilder<{
+        dataType: "custom";
+        data: string;
+        driverParam: string;
+    }>;
+    <TConfig extends Record<string, any>>(fieldConfig?: TConfig | undefined): import("drizzle-orm/sqlite-core").SQLiteCustomColumnBuilder<{
+        dataType: "custom";
+        data: string;
+        driverParam: string;
+    }>;
+    (dbname: string, fieldConfig?: unknown): import("drizzle-orm/sqlite-core").SQLiteCustomColumnBuilder<{
+        dataType: "custom";
+        data: string;
+        driverParam: string;
+    }>;
+};
+export declare const absoluteArrayColumn: {
+    (): import("drizzle-orm/sqlite-core").SQLiteCustomColumnBuilder<{
+        dataType: "custom";
+        data: (string & import("effect/Brand").Brand<"AbsolutePath">)[];
+        driverParam: string;
+    }>;
+    <TConfig extends Record<string, any>>(fieldConfig?: TConfig | undefined): import("drizzle-orm/sqlite-core").SQLiteCustomColumnBuilder<{
+        dataType: "custom";
+        data: (string & import("effect/Brand").Brand<"AbsolutePath">)[];
+        driverParam: string;
+    }>;
+    (dbname: string, fieldConfig?: unknown): import("drizzle-orm/sqlite-core").SQLiteCustomColumnBuilder<{
+        dataType: "custom";
+        data: (string & import("effect/Brand").Brand<"AbsolutePath">)[];
+        driverParam: string;
+    }>;
+};

package/dist/types/database/schema.gen.d.ts

@@ -0,0 +1,3 @@
+import type { DatabaseMigration } from "./migration.js";
+declare const schema: Omit<DatabaseMigration.Migration, "id">;
+export default schema;

package/dist/types/database/schema.sql.d.ts

@@ -0,0 +1,4 @@
+export declare const Timestamps: {
+    time_created: import("drizzle-orm").HasRuntimeDefault<import("drizzle-orm").HasDefault<import("drizzle-orm").NotNull<import("drizzle-orm/sqlite-core").SQLiteIntegerBuilder>>>;
+    time_updated: import("drizzle-orm").HasDefault<import("drizzle-orm").NotNull<import("drizzle-orm/sqlite-core").SQLiteIntegerBuilder>>;
+};

package/dist/types/database/sqlite.bun.d.ts

@@ -0,0 +1,14 @@
+import { Layer } from "effect";
+import { SqlClient } from "effect/unstable/sql";
+import { Sqlite } from "./sqlite.js";
+export declare const supportsTuningPragmas = true;
+export declare const supportsForeignKeyToggle = true;
+interface Config extends Sqlite.ClientConfig {
+    readonly filename: string;
+    readonly readonly?: boolean;
+    readonly create?: boolean;
+    readonly readwrite?: boolean;
+    readonly disableWAL?: boolean;
+}
+export declare const sqliteLayer: (config: Config) => Layer.Layer<SqlClient.SqlClient | Sqlite.Native, never, never>;
+export {};

package/dist/types/database/sqlite.d.ts

@@ -0,0 +1,20 @@
+export * as Sqlite from "./sqlite.js";
+import { Context, Effect, Scope } from "effect";
+import { SqlClient } from "effect/unstable/sql";
+import type { Connection } from "effect/unstable/sql/SqlConnection";
+import type { SqlError } from "effect/unstable/sql/SqlError";
+declare const Native_base: Context.ServiceClass<Native, "@opencode-ai/core/database/SqliteNative", unknown>;
+export declare class Native extends Native_base {
+}
+export interface ClientConfig {
+    readonly spanAttributes?: Record<string, unknown>;
+    readonly transformResultNames?: (str: string) => string;
+    readonly transformQueryNames?: (str: string) => string;
+}
+type Run = (query: string, params?: ReadonlyArray<unknown>) => Effect.Effect<ReadonlyArray<Record<string, unknown>>, SqlError>;
+type RunValues = (query: string, params?: ReadonlyArray<unknown>) => Effect.Effect<ReadonlyArray<ReadonlyArray<unknown>>, SqlError>;
+export declare const makeConnection: <Extensions extends object>(run: Run, runValues: RunValues, extensions: Extensions) => Connection & Extensions;
+export declare const makeClient: <Config extends ClientConfig, SqliteConnection extends Connection, const TypeId extends string, Extensions extends object>(options: Config, connection: SqliteConnection, typeId: TypeId, extensions: (acquirer: Effect.Effect<SqliteConnection, SqlError, Scope.Scope>) => Extensions) => Effect.Effect<SqlClient.SqlClient & Record<TypeId, TypeId> & {
+    readonly config: Config;
+    readonly updateValues: never;
+} & Extensions, never, import("effect/unstable/reactivity/Reactivity").Reactivity>;

package/dist/types/database/sqlite.node.d.ts

@@ -0,0 +1,16 @@
+import { Layer } from "effect";
+import { SqlClient } from "effect/unstable/sql";
+import { Sqlite } from "./sqlite.js";
+export declare const supportsTuningPragmas = true;
+export declare const supportsForeignKeyToggle = true;
+interface Config extends Sqlite.ClientConfig {
+    readonly filename: string;
+    readonly readonly?: boolean;
+    readonly create?: boolean;
+    readonly readwrite?: boolean;
+    readonly disableWAL?: boolean;
+    readonly timeout?: number;
+    readonly allowExtension?: boolean;
+}
+export declare const sqliteLayer: (config: Config) => Layer.Layer<SqlClient.SqlClient | Sqlite.Native, never, never>;
+export {};

package/dist/types/database/sqlite.workerd.d.ts

@@ -0,0 +1,29 @@
+import { Layer } from "effect";
+import { SqlClient } from "effect/unstable/sql";
+import { Sqlite } from "./sqlite.js";
+export declare const supportsTuningPragmas = false;
+export declare const supportsForeignKeyToggle = false;
+type SqlStorageValue = ArrayBuffer | string | number | null;
+interface SqlStorageCursor {
+    readonly columnNames: Array<string>;
+    raw(): IterableIterator<Array<SqlStorageValue>>;
+    toArray(): Array<Record<string, SqlStorageValue>>;
+}
+export interface SqlStorage {
+    exec(query: string, ...bindings: Array<unknown>): SqlStorageCursor;
+}
+export interface DurableObjectStorage {
+    readonly sql: SqlStorage;
+    transaction<T>(closure: (txn: {
+        rollback(): void;
+    }) => Promise<T>): Promise<T>;
+    transactionSync<T>(closure: () => T): T;
+}
+interface Config {
+    readonly storage: DurableObjectStorage;
+    readonly spanAttributes?: Record<string, unknown>;
+    readonly transformResultNames?: (str: string) => string;
+    readonly transformQueryNames?: (str: string) => string;
+}
+export declare const sqliteLayer: (config: Config) => Layer.Layer<SqlClient.SqlClient | Sqlite.Native, never, never>;
+export {};

package/dist/types/database/v1-migration.bun.d.ts

@@ -0,0 +1,71 @@
+export * as V1Migration from "./v1-migration.js";
+import { Effect, Layer } from "effect";
+import { Database } from "./database.js";
+import { SessionTable } from "../session/sql.js";
+import { SessionMessage } from "../session/message.js";
+import { Global } from "@opencode-ai/util/global";
+export type SourceMessage = {
+    readonly id: string;
+    readonly session_id: string;
+    readonly time_created: number;
+    readonly time_updated: number;
+    readonly data: string;
+};
+export type SourcePart = {
+    readonly id: string;
+    readonly message_id: string;
+    readonly session_id: string;
+    readonly time_created: number;
+    readonly time_updated: number;
+    readonly data: string;
+};
+export type TransformInput = {
+    readonly session: typeof SessionTable.$inferSelect;
+    readonly messages: ReadonlyArray<SourceMessage>;
+    readonly parts: ReadonlyArray<SourcePart>;
+};
+export type Warning = {
+    readonly reason: string;
+    readonly sessionID: string;
+    readonly messageID?: string;
+    readonly partID?: string;
+    readonly observedType?: string;
+};
+export type TransformResult = {
+    readonly messages: ReadonlyArray<{
+        readonly id: string;
+        readonly session_id: string;
+        readonly type: SessionMessage.Type;
+        readonly seq: number;
+        readonly time_created: number;
+        readonly time_updated: number;
+        readonly data: Record<string, unknown>;
+    }>;
+    readonly session: Pick<typeof SessionTable.$inferInsert, "agent" | "model" | "cost" | "tokens_input" | "tokens_output" | "tokens_reasoning" | "tokens_cache_read" | "tokens_cache_write" | "revert" | "time_compacting">;
+    readonly watermark: number;
+    readonly warnings: ReadonlyArray<Warning>;
+};
+type Progress = {
+    readonly label: string;
+    readonly numerator?: number;
+    readonly denominator?: number;
+};
+export type Status = {
+    readonly status: "required" | "completed";
+} | {
+    readonly status: "running";
+    readonly progress: Progress;
+} | {
+    readonly status: "error";
+    readonly error: string;
+};
+type RunResult = {
+    readonly status: "completed";
+};
+type Options = {
+    readonly nextDatabasePath?: string;
+};
+export declare function transformSession(input: TransformInput): TransformResult;
+export declare function status(): Effect.Effect<Status, never, Database.Service>;
+export declare const layer: Layer.Layer<never, never, Global.Service | Database.Service>;
+export declare function run(options?: Options): Effect.Effect<RunResult, never, Database.Service | Global.Service>;

package/dist/types/database/v1-migration.d.ts

@@ -0,0 +1,2 @@
+export * as V1Migration from "#v1-migration";
+export * from "#v1-migration";

package/dist/types/database/v1-migration.noop.d.ts

@@ -0,0 +1,11 @@
+import { Effect, Layer } from "effect";
+export type Status = {
+    readonly status: "completed";
+};
+export declare const layer: Layer.Layer<never, never, never>;
+export declare function status(): Effect.Effect<{
+    readonly status: "completed";
+}, never, never>;
+export declare function run(): Effect.Effect<{
+    readonly status: "completed";
+}, never, never>;

package/dist/types/effect/app-node-builder.d.ts

@@ -0,0 +1,3 @@
+import { LayerNode } from "@opencode-ai/util/effect/layer-node";
+export declare function build<A, E>(root: LayerNode.Node<A, E, any>, replacements?: LayerNode.Replacements): import("effect/Layer").Layer<A, E, never>;
+export * as AppNodeBuilder from "./app-node-builder.js";

package/dist/types/effect/app-node-platform.d.ts

@@ -0,0 +1,6 @@
+import { RequestExecutor } from "@opencode-ai/ai/route";
+import { Socket } from "effect/unstable/socket";
+export declare const requestExecutor: import("@opencode-ai/util/effect/layer-node").Node<RequestExecutor.Service, never, import("@opencode-ai/util/effect/layer-node").Tag<"global">>;
+export declare const llmClient: import("@opencode-ai/util/effect/layer-node").Node<import("@opencode-ai/ai").LLMClientService, never, import("@opencode-ai/util/effect/layer-node").Tag<"global">>;
+export declare const webSocketConstructor: import("@opencode-ai/util/effect/layer-node").Node<Socket.WebSocketConstructor, never, import("@opencode-ai/util/effect/layer-node").Tag<"global">>;
+export * as LayerNodePlatform from "./app-node-platform.js";

package/dist/types/effect/keyed-mutex.d.ts

@@ -0,0 +1,19 @@
+export * as KeyedMutex from "./keyed-mutex.js";
+import { Effect } from "effect";
+export interface KeyedMutex<in Key> {
+    readonly size: Effect.Effect<number>;
+    readonly withLock: (key: Key) => <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
+}
+/**
+ * Creates an in-memory mutex with one lock per key. Entries are removed when no
+ * holder or waiter remains.
+ *
+ *   same key      -> queue
+ *   different key -> run independently
+ *
+ * `users` counts holders and waiters so an entry is not removed while a waiter
+ * will reuse it.
+ */
+export declare const makeUnsafe: <Key>() => KeyedMutex<Key>;
+/** Creates an in-memory keyed mutex inside an Effect workflow. */
+export declare const make: <Key>() => Effect.Effect<KeyedMutex<Key>>;

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

@@ -0,0 +1,7 @@
+import type { ChildProcessSpawner } from "effect/unstable/process/ChildProcessSpawner";
+import type { FilesImpl } from "./files.js";
+export interface Driver {
+    readonly spawner: ChildProcessSpawner["Service"];
+    readonly overrides?: Partial<FilesImpl>;
+}
+export * as EnvironmentDriver from "./driver.js";

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

@@ -0,0 +1,12 @@
+import { Context } from "effect";
+import { ChildProcessSpawner } from "effect/unstable/process/ChildProcessSpawner";
+import type { Files } from "./files.js";
+export interface Interface {
+    readonly files: Files;
+    readonly spawner: ChildProcessSpawner["Service"];
+}
+declare const Service_base: Context.ServiceClass<Service, "@opencode/Environment", 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">>;
+export * as EnvironmentService from "./environment.js";

package/dist/types/environment/exec-defaults.d.ts

@@ -0,0 +1,4 @@
+import type { ChildProcessSpawner } from "effect/unstable/process/ChildProcessSpawner";
+import { type FilesImpl } from "./files.js";
+export declare const execDefaults: (spawner: ChildProcessSpawner["Service"]) => FilesImpl;
+export * as EnvironmentExecDefaults from "./exec-defaults.js";

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

@@ -0,0 +1,60 @@
+import { Effect, Schema } from "effect";
+export declare const FileType: Schema.Literals<readonly ["file", "directory", "symlink", "other"]>;
+export type FileType = typeof FileType.Type;
+export interface FileInfo {
+    readonly type: FileType;
+    readonly size: number;
+    readonly mtimeMs: number;
+}
+export interface DirEntry {
+    readonly name: string;
+    readonly type: FileType;
+}
+declare const NotFound_base: Schema.Class<NotFound, Schema.TaggedStruct<"Environment.NotFound", {
+    readonly path: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class NotFound extends NotFound_base {
+}
+declare const WrongKind_base: Schema.Class<WrongKind, Schema.TaggedStruct<"Environment.WrongKind", {
+    readonly path: Schema.String;
+    readonly actual: Schema.Literals<readonly ["file", "directory", "symlink", "other"]>;
+}>, import("effect/Cause").YieldableError>;
+export declare class WrongKind extends WrongKind_base {
+}
+declare const Failed_base: Schema.Class<Failed, Schema.TaggedStruct<"Environment.Failed", {
+    readonly path: Schema.String;
+    readonly cause: Schema.Defect;
+}>, import("effect/Cause").YieldableError>;
+export declare class Failed extends Failed_base {
+}
+export interface FilesImpl {
+    /**
+     * Content operations (`read`, `list`) follow final symlinks; metadata operations (`stat` and entry
+     * tags returned by `list`) do not. `info` describes the target file whose bytes are returned.
+     * The process-backed default caps collected output at 64 MiB; larger whole-file reads fail with
+     * `Failed`, so callers must use ranges for larger files.
+     */
+    readonly read: (path: string, range?: {
+        readonly offset: number;
+        readonly length: number;
+    }) => Effect.Effect<{
+        readonly info: FileInfo;
+        readonly bytes: Uint8Array;
+    }, NotFound | WrongKind | Failed>;
+    readonly write: (path: string, bytes: Uint8Array) => Effect.Effect<void, Failed>;
+    /** Describes the path entry itself, so a final symlink is reported as `symlink` rather than followed. */
+    readonly stat: (path: string) => Effect.Effect<FileInfo, NotFound | Failed>;
+    /** Follows a final symlink to the listed directory while preserving each returned entry's own type. */
+    readonly list: (path: string) => Effect.Effect<ReadonlyArray<DirEntry>, NotFound | WrongKind | Failed>;
+    readonly remove: (path: string) => Effect.Effect<void, Failed>;
+    readonly move: (from: string, to: string) => Effect.Effect<void, NotFound | Failed>;
+    readonly mkdir: (path: string) => Effect.Effect<void, Failed>;
+}
+export interface Files extends FilesImpl {
+}
+/**
+ * Derives a follow-stat kind from the lstat-like Files contract. A dangling
+ * symlink fails with `NotFound`.
+ */
+export declare const typeFollowing: (files: Files, path: string) => Effect.Effect<"directory" | "file" | "symlink" | "other", NotFound | Failed, never>;
+export * as EnvironmentFiles from "./files.js";

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

@@ -0,0 +1,10 @@
+export * as Environment from "./index.js";
+export { type Driver } from "./driver.js";
+export { type DirEntry, Failed, type FileInfo, type Files, type FilesImpl, type FileType, NotFound, typeFollowing, WrongKind, } from "./files.js";
+export { execDefaults } from "./exec-defaults.js";
+export { makeLocalDriver } from "./local.js";
+export { makeMemoryDriver, type MemoryDriver } from "./memory.js";
+export { type Interface, node, Service } from "./environment.js";
+import type { Driver } from "./driver.js";
+import type { Files } from "./files.js";
+export declare const makeFiles: (driver: Driver) => Files;

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

@@ -0,0 +1,13 @@
+import type { ChildProcessSpawner } from "effect/unstable/process/ChildProcessSpawner";
+import type { Driver } from "./driver.js";
+/**
+ * The host filesystem binding. Deliberately raw node:fs rather than effect's
+ * FileSystem service or FSUtil: the contract needs lstat semantics (stat
+ * reports "symlink") and typed directory entries, and effect's node
+ * FileSystem provides neither — its stat always follows symlinks and
+ * readDirectory returns names only. FSUtil hits the same gap and its
+ * readDirectoryEntries already bypasses to raw node readdir internally.
+ * Nothing above the environment seam touches node:fs.
+ */
+export declare const makeLocalDriver: (spawner: ChildProcessSpawner["Service"]) => Driver;
+export * as EnvironmentLocal from "./local.js";

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

@@ -0,0 +1,8 @@
+import { Effect } from "effect";
+import type { Driver } from "./driver.js";
+import { Failed } from "./files.js";
+export interface MemoryDriver extends Driver {
+    readonly symlink: (target: string, path: string) => Effect.Effect<void, Failed>;
+}
+export declare const makeMemoryDriver: () => MemoryDriver;
+export * as EnvironmentMemory from "./memory.js";

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

@@ -0,0 +1,20 @@
+import { Effect, Layer, PlatformError } from "effect";
+import { ChildProcessSpawner } from "effect/unstable/process/ChildProcessSpawner";
+export declare const spawner: {
+    spawn(command: import("effect/unstable/process/ChildProcess").Command): Effect.Effect<import("effect/unstable/process/ChildProcessSpawner").ChildProcessHandle, PlatformError.PlatformError, import("effect/Scope").Scope>;
+    exitCode(command: import("effect/unstable/process/ChildProcess").Command): Effect.Effect<import("effect/unstable/process/ChildProcessSpawner").ExitCode, PlatformError.PlatformError>;
+    streamString(command: import("effect/unstable/process/ChildProcess").Command, options?: {
+        readonly includeStderr?: boolean | undefined;
+    }): import("effect/Stream").Stream<string, PlatformError.PlatformError>;
+    streamLines(command: import("effect/unstable/process/ChildProcess").Command, options?: {
+        readonly includeStderr?: boolean | undefined;
+    }): import("effect/Stream").Stream<string, PlatformError.PlatformError>;
+    lines(command: import("effect/unstable/process/ChildProcess").Command, options?: {
+        readonly includeStderr?: boolean | undefined;
+    }): Effect.Effect<Array<string>, PlatformError.PlatformError>;
+    string(command: import("effect/unstable/process/ChildProcess").Command, options?: {
+        readonly includeStderr?: boolean | undefined;
+    }): Effect.Effect<string, PlatformError.PlatformError>;
+};
+export declare const layer: Layer.Layer<ChildProcessSpawner, never, never>;
+export * as EnvironmentUnavailable from "./unavailable.js";

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

@@ -0,0 +1,158 @@
+export declare const EventSequenceTable: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    name: "event_sequence";
+    schema: undefined;
+    columns: {
+        aggregate_id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "event_sequence";
+            dataType: "string";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        seq: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "event_sequence";
+            dataType: "number int53";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        owner_id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "event_sequence";
+            dataType: "string";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+    };
+    dialect: "sqlite";
+}>;
+export declare const EventTable: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    name: "event";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "event";
+            dataType: "string";
+            data: string & import("effect/Brand").Brand<"Event.ID">;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        aggregate_id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "event";
+            dataType: "string";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        seq: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "event";
+            dataType: "number int53";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        created: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "event";
+            dataType: "number int53";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        type: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "event";
+            dataType: "string";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        data: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "event";
+            dataType: "object json";
+            data: Record<string, unknown>;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+    };
+    dialect: "sqlite";
+}>;

package/dist/types/event-logger.d.ts

@@ -0,0 +1,5 @@
+export * as EventLogger from "./event-logger.js";
+import { Layer } from "effect";
+import { Bus } from "./bus.js";
+export declare const layer: Layer.Layer<never, never, Bus.Service>;
+export declare const node: import("@opencode-ai/util/effect/layer-node").Node<never, never, import("@opencode-ai/util/effect/layer-node").Tag<"global">>;

package/dist/types/file-mutation.d.ts

@@ -0,0 +1,40 @@
+export * as FileMutation from "./file-mutation.js";
+import { Context, Effect } from "effect";
+import { Environment } from "./environment/index.js";
+export interface Target {
+    readonly absolute: string;
+    readonly resource: string;
+}
+export interface WriteInput {
+    readonly target: Target;
+    readonly content: string | Uint8Array;
+}
+export interface TextWriteInput {
+    readonly target: Target;
+    readonly content: string;
+}
+export interface WriteResult {
+    readonly operation: "write";
+    readonly target: string;
+    readonly resource: string;
+    readonly existed: boolean;
+}
+export interface Interface {
+    /** Serialize a complete read/prepare/write mutation transaction by resolved path. */
+    readonly withLock: (targets: ReadonlyArray<string>) => <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
+    readonly write: (input: WriteInput) => Effect.Effect<WriteResult, Environment.Failed>;
+    /** Write text while retaining an existing UTF-8 BOM and emitting at most one BOM. */
+    readonly writeTextPreservingBom: (input: TextWriteInput) => Effect.Effect<WriteResult, Environment.WrongKind | Environment.Failed>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@opencode/FileMutation", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const readText: (files: Environment.Files, target: string) => Effect.Effect<{
+    bom: boolean;
+    text: string;
+}, Environment.NotFound | Environment.WrongKind | Environment.Failed, never>;
+export declare const syncTextBom: (files: Environment.Files, target: string, bom: boolean) => Effect.Effect<string, Environment.NotFound | Environment.WrongKind | Environment.Failed, never>;
+export declare const node: import("@opencode-ai/util/effect/layer-node").Node<Service, never, import("@opencode-ai/util/effect/layer-node").Tag<"location">>;
+/**
+ * Deferred until the corresponding integrations exist.
+ */

package/dist/types/file.d.ts

@@ -0,0 +1,9 @@
+export * as File from "./file.js";
+export declare const Diff: import("effect/Schema").Struct<{
+    readonly file: import("effect/Schema").String;
+    readonly patch: import("effect/Schema").String;
+    readonly additions: import("effect/Schema").Int;
+    readonly deletions: import("effect/Schema").Int;
+    readonly status: import("effect/Schema").Literals<readonly ["added", "deleted", "modified"]>;
+}>;
+export type Diff = typeof Diff.Type;