import type { Effect } from "effect";import { Data } from "effect"; // ---------------------------------------------------------------------------// ScopeDb — the per-scope app database (the shared primitive).//// One SQL database per scope: tools write it, workflows schedule tools, UI// reads it, skills route the agent to it. The self-hosted backing is one libSQL// (SQLite) file per scope; the cloud backing (future) is a Durable Object// facet. The seam carries a template-tag `sql` (the author-facing shape) plus// per-table version counters: every write bumps the touched table's version so// the LiveChannel can publish an invalidation and widgets refetch.//// Scope isolation is structural: `forScope(a)` and `forScope(b)` are distinct// databases; there is no cross-scope query path.// --------------------------------------------------------------------------- export class ScopeDbError extends Data.TaggedError("ScopeDbError")<{  readonly message: string;  readonly cause?: unknown;}> {} /** The author-facing db handle (matches `executor:app`'s `ScopeDb`): a tagged *  template returning rows. Also exposes the tables a statement touched so the *  runtime can bump version counters and publish invalidations. */export interface ScopeDbHandle {  readonly sql: <Row = Record<string, unknown>>(    strings: TemplateStringsArray,    ...values: unknown[]  ) => Effect.Effect<readonly Row[], ScopeDbError>;  /** Run a raw statement (used by the runtime for probes/migrations). */  readonly exec: <Row = Record<string, unknown>>(    sql: string,    params?: readonly unknown[],  ) => Effect.Effect<readonly Row[], ScopeDbError>;  /** Current version counter for a table (0 if never written). */  readonly tableVersion: (table: string) => Effect.Effect<number, ScopeDbError>;  /** Snapshot of every tracked table's version. */  readonly versions: () => Effect.Effect<ReadonlyMap<string, number>, ScopeDbError>;} /** A write that touched tables, with the versions after the bump. Emitted so *  the runtime can drive `LiveChannel.publish`. */export interface ScopeWriteEvent {  readonly scope: string;  readonly tables: readonly { readonly table: string; readonly version: number }[];} export interface ScopeDb {  readonly forScope: (scope: string) => Effect.Effect<ScopeDbHandle, ScopeDbError>;  /**   * Subscribe to writes across scopes (the runtime wires this into LiveChannel).   * Returns an unsubscribe thunk. Best-effort in-process; the cloud backing   * makes the storage owner the notifier.   */  readonly onWrite: (listener: (event: ScopeWriteEvent) => void) => () => void;  readonly close: () => Effect.Effect<void, ScopeDbError>;}