rnxsim 0.0.0 → 0.1.313

package/src/index.ts

@@ -1,706 +1,13 @@
-// better-auth adapter for sqlite-shaped stores (Cloudflare D1, bun:sqlite,
-// node:sqlite). hand-written against better-auth's CustomAdapter contract so
-// we don't pull in kysely or drizzle just to run prepared statements.
+// sootsim public package — CLI + framework integrations.
 //
-// the adapter accepts a minimal `Sqlite` executor interface — anything that
-// can `exec(sql, params)` and return rows/meta. drivers for the three target
-// stores live alongside: `d1Driver`, `bunSqliteDriver`, `nodeSqliteDriver`.
-//
-// schema generation (createSchema) emits a CREATE TABLE script from
-// better-auth's resolved BetterAuthDBSchema. apply once at deploy time.
-
-import { createAdapterFactory } from '@better-auth/core/db/adapter'
-import type { BetterAuthDBSchema, DBFieldAttribute } from '@better-auth/core/db'
-import type {
-  AdapterFactoryOptions,
-  CustomAdapter,
-  CleanedWhere,
-} from '@better-auth/core/db/adapter'
-
-// ── executor abstraction ──────────────────────────────────────────────────
-// what the adapter actually needs from the underlying store. all three drivers
-// (d1, bun-sqlite, node-sqlite) hide behind this shape so the adapter logic
-// stays the same.
-
-export interface SqliteExecutor {
-  /** run a query that returns rows */
-  all<T = Record<string, unknown>>(sql: string, params: readonly unknown[]): Promise<T[]>
-  /** run a query that returns a single row or null */
-  first<T = Record<string, unknown>>(
-    sql: string,
-    params: readonly unknown[],
-  ): Promise<T | null>
-  /** run a mutation (INSERT/UPDATE/DELETE) — returns rows-affected */
-  run(sql: string, params: readonly unknown[]): Promise<{ changes: number }>
-  /** run a raw schema statement (no params) */
-  exec(sql: string): Promise<void>
-}
-
-// minimal D1 binding surface — matches @cloudflare/workers-types without
-// importing it (keeps the package zero-dep at type-level).
-interface D1DatabaseLike {
-  prepare(sql: string): {
-    bind(...params: unknown[]): {
-      all<T = unknown>(): Promise<{ results: T[]; meta?: { changes?: number } }>
-      first<T = unknown>(): Promise<T | null>
-      run(): Promise<{ meta?: { changes?: number } }>
-    }
-  }
-  exec(sql: string): Promise<unknown>
-}
-
-export function d1Driver(db: D1DatabaseLike): SqliteExecutor {
-  return {
-    all: async (sql, params) => {
-      const { results } = await db
-        .prepare(sql)
-        .bind(...params)
-        .all()
-      return (results ?? []) as never
-    },
-    first: async (sql, params) => {
-      return (await db
-        .prepare(sql)
-        .bind(...params)
-        .first()) as never
-    },
-    run: async (sql, params) => {
-      const { meta } = await db
-        .prepare(sql)
-        .bind(...params)
-        .run()
-      return { changes: meta?.changes ?? 0 }
-    },
-    exec: async (sql) => {
-      // D1.exec treats *every* newline as a statement boundary, which
-      // explodes when buildSchemaSql emits multi-line `CREATE TABLE (...)`.
-      // Split on `;` (the canonical SQL terminator), drop empties, then
-      // dispatch each statement via prepare().run() so D1 sees one
-      // statement per call. Each statement may freely contain newlines.
-      const statements = sql
-        .split(/;\s*/)
-        .map((s) => s.trim())
-        .filter(Boolean)
-      for (const stmt of statements) {
-        await db.prepare(stmt).bind().run()
-      }
-    },
-  }
-}
-
-// bun:sqlite / node:sqlite — they share enough surface that one shim covers
-// both. you pass in a Database instance and we drive it.
-interface NodeBunSqliteDatabase {
-  prepare(sql: string): {
-    all(...params: unknown[]): unknown[]
-    get(...params: unknown[]): unknown
-    run(...params: unknown[]): { changes?: number }
-  }
-  exec(sql: string): unknown
-}
-
-export function nodeBunSqliteDriver(db: NodeBunSqliteDatabase): SqliteExecutor {
-  return {
-    all: async (sql, params) => db.prepare(sql).all(...params) as never,
-    first: async (sql, params) => (db.prepare(sql).get(...params) as never) ?? null,
-    run: async (sql, params) => {
-      const res = db.prepare(sql).run(...params)
-      return { changes: res.changes ?? 0 }
-    },
-    exec: async (sql) => {
-      db.exec(sql)
-    },
-  }
-}
-
-// ── SQL builders ──────────────────────────────────────────────────────────
-// rendering happens against `CleanedWhere` after better-auth has normalised
-// model/field names via getModelName/getFieldName.
-
-const quote = (id: string) => `"${id.replace(/"/g, '""')}"`
-
-function renderWhereClause(where: CleanedWhere[]): {
-  sql: string
-  params: unknown[]
-} {
-  if (where.length === 0) return { sql: '', params: [] }
-  const parts: string[] = []
-  const params: unknown[] = []
-  for (let i = 0; i < where.length; i++) {
-    const clause = where[i]
-    const connector = i === 0 ? '' : ` ${clause.connector} `
-    const field = quote(clause.field)
-    let frag: string
-    switch (clause.operator) {
-      case 'eq':
-        if (clause.value === null) frag = `${field} IS NULL`
-        else {
-          frag = `${field} = ?`
-          params.push(serialize(clause.value))
-        }
-        break
-      case 'ne':
-        if (clause.value === null) frag = `${field} IS NOT NULL`
-        else {
-          frag = `${field} != ?`
-          params.push(serialize(clause.value))
-        }
-        break
-      case 'lt':
-        frag = `${field} < ?`
-        params.push(serialize(clause.value))
-        break
-      case 'lte':
-        frag = `${field} <= ?`
-        params.push(serialize(clause.value))
-        break
-      case 'gt':
-        frag = `${field} > ?`
-        params.push(serialize(clause.value))
-        break
-      case 'gte':
-        frag = `${field} >= ?`
-        params.push(serialize(clause.value))
-        break
-      case 'in': {
-        const arr = clause.value as readonly unknown[]
-        if (!arr.length) {
-          frag = '0'
-          break
-        }
-        frag = `${field} IN (${arr.map(() => '?').join(',')})`
-        for (const v of arr) params.push(serialize(v))
-        break
-      }
-      case 'not_in': {
-        const arr = clause.value as readonly unknown[]
-        if (!arr.length) {
-          frag = '1'
-          break
-        }
-        frag = `${field} NOT IN (${arr.map(() => '?').join(',')})`
-        for (const v of arr) params.push(serialize(v))
-        break
-      }
-      case 'contains':
-        frag = `${field} LIKE ?`
-        params.push(`%${String(clause.value)}%`)
-        break
-      case 'starts_with':
-        frag = `${field} LIKE ?`
-        params.push(`${String(clause.value)}%`)
-        break
-      case 'ends_with':
-        frag = `${field} LIKE ?`
-        params.push(`%${String(clause.value)}`)
-        break
-      default:
-        throw new Error(`[better-auth-d1] unsupported operator: ${clause.operator}`)
-    }
-    parts.push(connector + frag)
-  }
-  return { sql: ` WHERE ${parts.join('')}`, params }
-}
-
-// SQLite has no native boolean/date/json — we encode them on the way in and
-// decode on the way out. better-auth keeps its own input typing so we don't
-// have to guess: anything that looks like a Date / object becomes a string,
-// booleans become 0/1.
-function serialize(value: unknown): unknown {
-  if (value === undefined || value === null) return null
-  if (value instanceof Date) return value.toISOString()
-  if (typeof value === 'boolean') return value ? 1 : 0
-  if (Array.isArray(value)) return JSON.stringify(value)
-  if (typeof value === 'object') return JSON.stringify(value)
-  return value
-}
-
-function deserializeRow(
-  row: Record<string, unknown>,
-  schemaFields: Record<string, DBFieldAttribute>,
-): Record<string, unknown> {
-  const out: Record<string, unknown> = {}
-  for (const [k, v] of Object.entries(row)) {
-    const attr = schemaFields[k]
-    if (!attr) {
-      out[k] = v
-      continue
-    }
-    if (v === null || v === undefined) {
-      out[k] = null
-      continue
-    }
-    if (attr.type === 'boolean') {
-      out[k] = v === 1 || v === '1' || v === true
-    } else if (attr.type === 'date') {
-      out[k] = typeof v === 'string' ? new Date(v) : v
-    } else if (
-      attr.type === 'json' ||
-      attr.type === 'string[]' ||
-      attr.type === 'number[]'
-    ) {
-      out[k] = typeof v === 'string' ? safeJsonParse(v) : v
-    } else {
-      // string | number — sqlite returns native types
-      out[k] = v
-    }
-  }
-  return out
-}
-
-function safeJsonParse(s: string): unknown {
-  try {
-    return JSON.parse(s)
-  } catch {
-    return s
-  }
-}
-
-function fieldsOf(schema: BetterAuthDBSchema, model: string) {
-  return schema[model]?.fields ?? {}
-}
-
-// ── schema generation ─────────────────────────────────────────────────────
-// build a CREATE TABLE script from the better-auth schema, so deploy time
-// can apply it once against a fresh D1 / sqlite file.
-
-function sqlType(field: DBFieldAttribute): string {
-  if (field.type === 'number' || field.type === 'boolean') return 'INTEGER'
-  // string | date | json | string[] | number[] | string-enum-array → TEXT
-  return 'TEXT'
-}
-
-export function buildSchemaSql(schema: BetterAuthDBSchema): string {
-  const stmts: string[] = []
-  for (const [, model] of Object.entries(schema)) {
-    const cols: string[] = ['"id" TEXT PRIMARY KEY NOT NULL']
-    for (const [fieldName, attr] of Object.entries(model.fields)) {
-      if (fieldName === 'id') continue
-      const parts = [quote(fieldName), sqlType(attr)]
-      if (attr.required !== false && attr.defaultValue === undefined) {
-        // better-auth treats `required:true` as `defaultValue` may be
-        // provided at runtime; only mark NOT NULL when there's no risk of
-        // the field being absent on insert.
-        if (attr.required === true) parts.push('NOT NULL')
-      }
-      if (attr.unique) parts.push('UNIQUE')
-      cols.push(parts.join(' '))
-    }
-    stmts.push(
-      `CREATE TABLE IF NOT EXISTS ${quote(model.modelName)} (\n  ${cols.join(',\n  ')}\n);`,
-    )
-  }
-  return stmts.join('\n\n') + '\n'
-}
-
-// ── adapter factory ───────────────────────────────────────────────────────
-
-export interface D1AdapterConfig {
-  /**
-   * Pre-built executor. Use one of the bundled drivers (`d1Driver` /
-   * `nodeBunSqliteDriver`) or implement `SqliteExecutor` yourself.
-   */
-  executor: SqliteExecutor
-  /**
-   * Use plural table names. better-auth defaults to singular; keep that
-   * unless your existing schema is plural.
-   */
-  usePlural?: boolean
-  debugLogs?: boolean
-  /**
-   * Apply `buildSchemaSql(schema)` on the first DB operation. The generated
-   * statements are `CREATE TABLE IF NOT EXISTS`, so this is safe to run
-   * every cold start. Defaults to true — set false if you prefer to run
-   * migrations explicitly (e.g. via `wrangler d1 execute --file=<sql>` at
-   * deploy time).
-   */
-  autoMigrate?: boolean
-}
-
-export function d1Adapter(config: D1AdapterConfig) {
-  const exec = config.executor
-  return createAdapterFactory({
-    config: {
-      adapterId: 'contrast-d1',
-      adapterName: 'Contrast D1 Adapter',
-      usePlural: config.usePlural ?? false,
-      debugLogs: config.debugLogs ?? false,
-      supportsArrays: false,
-      // Sqlite doesn't have a native bool/date type — better-auth's transform
-      // layer + our serialize() handle the round-trip.
-      supportsBooleans: false,
-      supportsDates: false,
-      supportsJSON: false,
-      transaction: false,
-    } as AdapterFactoryOptions['config'],
-    adapter: ({ schema, getFieldName, getModelName }) => {
-      const table = (model: string) => quote(getModelName(model))
-      const select = (model: string, columns?: string[]) =>
-        columns?.length
-          ? columns.map((c) => quote(getFieldName({ model, field: c }))).join(', ')
-          : '*'
-
-      // lazy auto-migration. better-auth's resolved schema arrives here in
-      // `schema`; we hand it to buildSchemaSql and apply once per process.
-      // every method calls ensureSchema() at the top so even a fresh sqlite
-      // file gets bootstrapped on the first /api/auth/* request.
-      let schemaApplied = config.autoMigrate === false
-      const ensureSchema = async () => {
-        if (schemaApplied) return
-        await exec.exec(buildSchemaSql(schema))
-        schemaApplied = true
-      }
-
-      const adapter: CustomAdapter = {
-        create: async ({ model, data }) => {
-          await ensureSchema()
-          const cols = Object.keys(data).map((k) =>
-            quote(getFieldName({ model, field: k })),
-          )
-          const values = Object.values(data).map(serialize)
-          const placeholders = cols.map(() => '?').join(',')
-          await exec.run(
-            `INSERT INTO ${table(model)} (${cols.join(',')}) VALUES (${placeholders})`,
-            values,
-          )
-          return data as never
-        },
-
-        findOne: async ({ model, where, select: cols }) => {
-          await ensureSchema()
-          const w = renderWhereClause(where)
-          const row = await exec.first(
-            `SELECT ${select(model, cols)} FROM ${table(model)}${w.sql} LIMIT 1`,
-            w.params,
-          )
-          if (!row) return null
-          return deserializeRow(row, fieldsOf(schema, getModelName(model))) as never
-        },
-
-        findMany: async ({ model, where, limit, offset, sortBy, select: cols }) => {
-          await ensureSchema()
-          const w = renderWhereClause(where ?? [])
-          let sql = `SELECT ${select(model, cols)} FROM ${table(model)}${w.sql}`
-          if (sortBy) {
-            const field = quote(getFieldName({ model, field: sortBy.field }))
-            sql += ` ORDER BY ${field} ${sortBy.direction.toUpperCase()}`
-          }
-          if (limit !== undefined) sql += ` LIMIT ${limit}`
-          // sqlite rejects OFFSET without LIMIT; -1 means unlimited
-          if (offset !== undefined)
-            sql += `${limit === undefined ? ' LIMIT -1' : ''} OFFSET ${offset}`
-          const rows = await exec.all(sql, w.params)
-          const fields = fieldsOf(schema, getModelName(model))
-          return rows.map((r) => deserializeRow(r, fields)) as never[]
-        },
-
-        count: async ({ model, where }) => {
-          await ensureSchema()
-          const w = renderWhereClause(where ?? [])
-          const row = await exec.first<{ c: number }>(
-            `SELECT COUNT(*) AS c FROM ${table(model)}${w.sql}`,
-            w.params,
-          )
-          return row?.c ?? 0
-        },
-
-        update: async ({ model, where, update }) => {
-          await ensureSchema()
-          const cols = Object.keys(update as Record<string, unknown>)
-          if (!cols.length) return null
-          const sets = cols
-            .map((c) => `${quote(getFieldName({ model, field: c }))} = ?`)
-            .join(', ')
-          const setParams = cols.map((c) =>
-            serialize((update as Record<string, unknown>)[c]),
-          )
-          const w = renderWhereClause(where)
-          await exec.run(`UPDATE ${table(model)} SET ${sets}${w.sql}`, [
-            ...setParams,
-            ...w.params,
-          ])
-          // re-read to return the updated row
-          const row = await exec.first(
-            `SELECT * FROM ${table(model)}${w.sql} LIMIT 1`,
-            w.params,
-          )
-          if (!row) return null
-          return deserializeRow(row, fieldsOf(schema, getModelName(model))) as never
-        },
-
-        updateMany: async ({ model, where, update }) => {
-          await ensureSchema()
-          const cols = Object.keys(update)
-          if (!cols.length) return 0
-          const sets = cols
-            .map((c) => `${quote(getFieldName({ model, field: c }))} = ?`)
-            .join(', ')
-          const setParams = cols.map((c) => serialize(update[c]))
-          const w = renderWhereClause(where)
-          const res = await exec.run(`UPDATE ${table(model)} SET ${sets}${w.sql}`, [
-            ...setParams,
-            ...w.params,
-          ])
-          return res.changes
-        },
-
-        delete: async ({ model, where }) => {
-          await ensureSchema()
-          const w = renderWhereClause(where)
-          await exec.run(`DELETE FROM ${table(model)}${w.sql}`, w.params)
-        },
-
-        deleteMany: async ({ model, where }) => {
-          await ensureSchema()
-          const w = renderWhereClause(where)
-          const res = await exec.run(`DELETE FROM ${table(model)}${w.sql}`, w.params)
-          return res.changes
-        },
-
-        createSchema: async ({ tables }) => ({
-          path: 'better-auth.schema.sql',
-          code: buildSchemaSql(tables),
-          overwrite: true,
-        }),
-      }
-
-      return adapter
-    },
-  })
-}
-
-// ── localStorage adapter ──────────────────────────────────────────────────
-// preview/browser-only dev path. better-auth still runs server-side in the
-// Contrast preview's bundled "server" module, but that module runs *in the
-// browser*, so node:sqlite / bun:sqlite aren't available. localStorage gives
-// a 1-LOC backing store that persists across reloads inside the iframe.
-//
-// special-cased: this is a direct CustomAdapter (no SQL emission), so the
-// data stored in localStorage is plain JSON rows — easier to inspect via
-// devtools and avoids dragging sql.js in.
-
-export interface LocalStorageLike {
-  getItem(k: string): string | null
-  setItem(k: string, v: string): void
-}
-
-export interface LocalStorageAdapterConfig {
-  /** prefix for localStorage keys. defaults to `better-auth:`. */
-  prefix?: string
-  /** plural model names (matches better-auth's `usePlural` option). */
-  usePlural?: boolean
-  debugLogs?: boolean
-  /** custom Storage impl — defaults to `globalThis.localStorage`. */
-  storage?: LocalStorageLike
-}
-
-function localStorageMethod(value: unknown, key: keyof LocalStorageLike): unknown {
-  if (typeof value !== 'object' || value === null) return undefined
-  // boundary assertion for unknown host globals such as node's localStorage.
-  return (value as Record<keyof LocalStorageLike, unknown>)[key]
-}
-
-export function isLocalStorageLike(value: unknown): value is LocalStorageLike {
-  return (
-    typeof localStorageMethod(value, 'getItem') === 'function' &&
-    typeof localStorageMethod(value, 'setItem') === 'function'
-  )
-}
-
-function readGlobalLocalStorage(): unknown {
-  try {
-    return globalThis.localStorage
-  } catch {
-    return null
-  }
-}
-
-function localStorageStore(
-  prefix: string,
-  storage: LocalStorageAdapterConfig['storage'],
-) {
-  const get = () => {
-    const candidate = storage ?? readGlobalLocalStorage()
-    return isLocalStorageLike(candidate) ? candidate : null
-  }
-  return {
-    load: (model: string): Record<string, unknown>[] => {
-      const s = get()
-      if (!s) return []
-      const raw = s.getItem(prefix + model)
-      return raw ? ((safeJsonParse(raw) as Record<string, unknown>[]) ?? []) : []
-    },
-    save: (model: string, rows: Record<string, unknown>[]) => {
-      const s = get()
-      if (!s) return
-      s.setItem(prefix + model, JSON.stringify(rows))
-    },
-  }
-}
-
-function matchesWhere(
-  row: Record<string, unknown>,
-  where: readonly CleanedWhere[],
-): boolean {
-  if (!where.length) return true
-  // better-auth always emits flat AND/OR clauses; the connector applies to the
-  // step between clause i-1 and i. we evaluate left-to-right with short-circuit.
-  let result = matchClause(row, where[0])
-  for (let i = 1; i < where.length; i++) {
-    const c = where[i]
-    const v = matchClause(row, c)
-    result = c.connector === 'OR' ? result || v : result && v
-  }
-  return result
-}
-
-function matchClause(row: Record<string, unknown>, c: CleanedWhere): boolean {
-  const lhs = row[c.field]
-  const rhs = c.value
-  switch (c.operator) {
-    case 'eq':
-      return lhs === rhs || (lhs == null && rhs == null)
-    case 'ne':
-      return lhs !== rhs
-    case 'lt':
-      return (lhs as number) < (rhs as number)
-    case 'lte':
-      return (lhs as number) <= (rhs as number)
-    case 'gt':
-      return (lhs as number) > (rhs as number)
-    case 'gte':
-      return (lhs as number) >= (rhs as number)
-    case 'in':
-      return (rhs as readonly unknown[]).includes(lhs)
-    case 'not_in':
-      return !(rhs as readonly unknown[]).includes(lhs)
-    case 'contains':
-      return String(lhs ?? '').includes(String(rhs))
-    case 'starts_with':
-      return String(lhs ?? '').startsWith(String(rhs))
-    case 'ends_with':
-      return String(lhs ?? '').endsWith(String(rhs))
-    default:
-      throw new Error(`[better-auth-d1/localStorage] unsupported operator: ${c.operator}`)
-  }
-}
-
-function projectRow(
-  row: Record<string, unknown>,
-  cols: string[] | undefined,
-): Record<string, unknown> {
-  if (!cols?.length) return row
-  const out: Record<string, unknown> = {}
-  for (const c of cols) out[c] = row[c]
-  return out
-}
-
-export function localStorageAdapter(config: LocalStorageAdapterConfig = {}) {
-  const prefix = config.prefix ?? 'better-auth:'
-  const store = localStorageStore(prefix, config.storage)
-
-  return createAdapterFactory({
-    config: {
-      adapterId: 'contrast-localstorage',
-      adapterName: 'Contrast localStorage Adapter',
-      usePlural: config.usePlural ?? false,
-      debugLogs: config.debugLogs ?? false,
-      supportsArrays: true,
-      supportsBooleans: true,
-      supportsDates: true,
-      supportsJSON: true,
-      transaction: false,
-    } as AdapterFactoryOptions['config'],
-    adapter: ({ getModelName }) => {
-      const tableName = (model: string) => getModelName(model)
-
-      const adapter: CustomAdapter = {
-        create: async ({ model, data }) => {
-          const t = tableName(model)
-          const rows = store.load(t)
-          rows.push(data as Record<string, unknown>)
-          store.save(t, rows)
-          return data as never
-        },
-
-        findOne: async ({ model, where, select: cols }) => {
-          const rows = store.load(tableName(model))
-          for (const r of rows) {
-            if (matchesWhere(r, where)) return projectRow(r, cols) as never
-          }
-          return null
-        },
-
-        findMany: async ({ model, where, limit, offset, sortBy, select: cols }) => {
-          const all = store.load(tableName(model))
-          let rows = where ? all.filter((r) => matchesWhere(r, where)) : all
-          if (sortBy) {
-            const { field, direction } = sortBy
-            const dir = direction === 'desc' ? -1 : 1
-            rows = [...rows].sort((a, b) => {
-              const av = a[field] as never
-              const bv = b[field] as never
-              if (av === bv) return 0
-              return (av < bv ? -1 : 1) * dir
-            })
-          }
-          if (offset) rows = rows.slice(offset)
-          if (limit !== undefined) rows = rows.slice(0, limit)
-          return rows.map((r) => projectRow(r, cols)) as never[]
-        },
-
-        count: async ({ model, where }) => {
-          const all = store.load(tableName(model))
-          return where ? all.filter((r) => matchesWhere(r, where)).length : all.length
-        },
-
-        update: async ({ model, where, update }) => {
-          const t = tableName(model)
-          const rows = store.load(t)
-          let updated: Record<string, unknown> | null = null
-          for (let i = 0; i < rows.length; i++) {
-            if (matchesWhere(rows[i], where)) {
-              rows[i] = { ...rows[i], ...(update as Record<string, unknown>) }
-              updated = rows[i]
-              break
-            }
-          }
-          if (updated) store.save(t, rows)
-          return updated as never
-        },
-
-        updateMany: async ({ model, where, update }) => {
-          const t = tableName(model)
-          const rows = store.load(t)
-          let n = 0
-          for (let i = 0; i < rows.length; i++) {
-            if (matchesWhere(rows[i], where)) {
-              rows[i] = { ...rows[i], ...(update as Record<string, unknown>) }
-              n++
-            }
-          }
-          if (n) store.save(t, rows)
-          return n
-        },
-
-        delete: async ({ model, where }) => {
-          const t = tableName(model)
-          const rows = store.load(t)
-          const next = rows.filter((r) => !matchesWhere(r, where))
-          if (next.length !== rows.length) store.save(t, next)
-        },
-
-        deleteMany: async ({ model, where }) => {
-          const t = tableName(model)
-          const rows = store.load(t)
-          const next = rows.filter((r) => !matchesWhere(r, where))
-          const removed = rows.length - next.length
-          if (removed) store.save(t, next)
-          return removed
-        },
-      }
-
-      return adapter
-    },
-  })
-}
+// the bridge client and plugins live here. the canvas rendering engine lives
+// in the private `sootsim-engine` workspace package.
+
+export { sootsimPlugin } from './vite-plugin-one'
+export { default as metroPlugin } from './metro-plugin'
+export { default as jumpToSourceBabelPlugin } from './jump-to-source-babel'
+export {
+  DEFAULT_SOOTSIM_BRIDGE_PORT,
+  DEFAULT_SOOTSIM_BRIDGE_URL,
+} from './bridge-constants'
+export { DEFAULT_SOOTSIM_SHELL_URL } from './cli-constants'