lecodes-cli 0.16.1 → 0.17.0

package/runtime/sdk/server/db/defineDb.ts

@@ -0,0 +1,237 @@
+/**
+ * `model({...})` + `defineDb({ User, Post })` — the schema registry and the typed db handle.
+ *
+ * Runtime responsibilities: validate relation names, resolve `t.many()` back-fields, emit the `.marci`
+ * schema text (`db.$schema`), and turn collection calls into lazy `Op`s over a `MarciTransport`
+ * (`marcidb-embedded` handle, HTTP client, or a test fake). The transport is either passed to
+ * `defineDb(models, { transport })` or provided by the host through `setDbTransport()` — user code
+ * never sees a connection string.
+ */
+
+import type { Field, FieldDef, ScalarKind } from "./fields"
+import { AUTH_SESSION_MODEL, AUTH_USER_MODEL, authSessionModel, isAuthModel, sessionUserField } from "../auth/models"
+import { createQueryLayer, type FieldDesc, type MarciOp, type MarciTransport, type ModelsMeta } from "./marci/query"
+import type { AuthBinding, Db, Fields, Model, Schema, ValidateRefs } from "./types"
+
+export const model = <F extends Fields>(fields: F): Model<F> => ({ fields, __model: true })
+
+// ───────────────────────────── transport ─────────────────────────────
+
+// A GLOBAL seam (not a module variable): the compiled server bundle carries its own copy of this
+// module, so the host's `setDbTransport` and the bundle's `defineDb` only meet through globalThis.
+const seam = globalThis as unknown as { __lecodesDbTransport?: MarciTransport, __lecodesDbs?: Db<any>[] }
+/** Host hook: the runner/dev-server installs the project's transport before loading user code. */
+export const setDbTransport = (transport: MarciTransport | null) => {
+  if (transport) seam.__lecodesDbTransport = transport
+  else delete seam.__lecodesDbTransport
+}
+/**
+ * Every `defineDb` call registers its handle here so the host finds the schema whether or not the
+ * project exports `db` (`const db = defineDb(...)` used only inside endpoints is the common case).
+ * The host reads and clears the list after evaluating a bundle (`loadServerModules`).
+ */
+export const takeRegisteredDbs = (): Db<any>[] => {
+  const dbs = seam.__lecodesDbs ?? []
+  seam.__lecodesDbs = []
+  return dbs
+}
+
+const opOf = (o: unknown): MarciOp => {
+  const op = (o as { __op?: MarciOp })?.__op
+  if (!op) throw new Error("db.$transaction: every item must be a db.<model>.<method>(...) call")
+  return op
+}
+
+/** A reference to a previous operation's result inside `$transaction` (resolved server-side): `ref("0.id")`. */
+export const ref = (path: string): any => ({ $ref: path })
+
+// ───────────────────────────── metadata ─────────────────────────────
+
+type ModelMeta = {
+  name: string
+  fields: Record<string, FieldDef>
+  idKeys: string[]
+  /** id is a single uuid key we generate on insert. */
+  uuidId: boolean
+}
+
+const isRel = (d: FieldDef) => d.kind === "one" || d.kind === "many" || d.kind === "list"
+
+const buildMeta = (models: Record<string, Model>): Record<string, ModelMeta> => {
+  const metas: Record<string, ModelMeta> = {}
+  for (const [name, m] of Object.entries(models)) {
+    if (!/^[A-Z][A-Za-z0-9]*$/.test(name)) throw new Error(`defineDb: model name "${name}" must be PascalCase`)
+    const fields: Record<string, FieldDef> = {}
+    for (const [key, f] of Object.entries(m.fields as Fields)) fields[key] = { ...(f as Field<any, any>).def }
+    if (fields.id && !fields.id.isId) fields.id.isId = true
+    const idKeys = Object.keys(fields).filter(k => fields[k].isId)
+    const uuidId = idKeys.length === 1 && idKeys[0] === "id" && fields.id.scalar === "uuid"
+    metas[name] = { name, fields, idKeys, uuidId }
+  }
+  // relations: targets must exist; `many` needs a back field
+  for (const meta of Object.values(metas)) {
+    for (const [key, d] of Object.entries(meta.fields)) {
+      if (!isRel(d)) continue
+      const target = metas[d.model!]
+      if (!target) throw new Error(`defineDb: ${meta.name}.${key} references unknown model "${d.model}"`)
+      if (d.kind !== "many") continue
+      if (d.back) {
+        const back = target.fields[d.back]
+        if (!back || back.kind !== "one" || back.model !== meta.name)
+          throw new Error(`defineDb: ${meta.name}.${key}: "${d.model}.${d.back}" is not a t.one("${meta.name}") field`)
+        continue
+      }
+      const candidates = Object.entries(target.fields).filter(([, f]) => f.kind === "one" && f.model === meta.name).map(([k]) => k)
+      if (candidates.length !== 1)
+        throw new Error(
+          `defineDb: ${meta.name}.${key}: cannot infer the back field on ${d.model} ` +
+          (candidates.length ? `(candidates: ${candidates.join(", ")}) — pass it: t.many("${d.model}", "<field>")`
+                             : `— add a t.one("${meta.name}") field to ${d.model}`))
+      d.back = candidates[0]
+    }
+  }
+  return metas
+}
+
+// ───────────────────────────── .marci emitter ─────────────────────────────
+
+const SCALAR: Record<Exclude<ScalarKind, "">, string> = {
+  string: "String", int: "Int", float: "Double", bool: "Bool", date: "DateTime", uuid: "Byte[16]",
+}
+const cap = (s: string) => s.charAt(0).toUpperCase() + s.slice(1)
+const ON_DELETE = { cascade: "Cascade", setNull: "SetNull", restrict: "Restrict" } as const
+
+const literal = (v: unknown, d: FieldDef): string => {
+  if (d.scalar === "date" && v === "now") return "now()"
+  if (Array.isArray(v)) return `[${v.map(x => literal(x, { ...d, array: false })).join(", ")}]`
+  if (typeof v === "string") return d.kind === "enum" ? v : JSON.stringify(v)
+  return String(v)
+}
+
+const emitField = (owner: string, key: string, d: FieldDef, extra: string[]): string => {
+  let type: string
+  const attrs: string[] = []
+  switch (d.kind) {
+    case "scalar":
+      type = d.vector ? `Float[${d.vector.size}]` : SCALAR[d.scalar as Exclude<ScalarKind, "">]
+      if (d.scalar === "uuid") attrs.push("@format(uuid)")
+      break
+    case "json": type = "Json"; break
+    case "enum": {
+      const name = `${owner}${cap(key)}`
+      extra.push(`enum ${name} {\n${d.values!.map(v => `    ${v}`).join("\n")}\n}`)
+      type = name; break
+    }
+    case "struct": {
+      const name = `${owner}${cap(key)}`
+      const inner: string[] = []
+      for (const [k, f] of Object.entries(d.fields!)) inner.push(emitField(name, k, (f as Field<any, any>).def, extra))
+      extra.push(`struct ${name} {\n${inner.join("\n")}\n}`)
+      type = name; break
+    }
+    case "one": type = d.model!; break
+    case "many": type = `${d.model}[]`; attrs.push(`@bind(${d.model}.${d.back})`); break
+    case "list": type = `${d.model}[]`; attrs.push("@list"); break
+  }
+  if (d.array && d.kind !== "many" && d.kind !== "list") type += "[]"
+  if (d.optional) type += "?"
+  if (d.isId) attrs.unshift("@id")
+  if (d.unique) attrs.push("@unique")
+  if (d.index) attrs.push("@index")
+  if (d.hasDefault) attrs.push(`@default(${literal(d.default, d)})`)
+  if (d.onDelete) attrs.push(`@onDelete(${ON_DELETE[d.onDelete]})`)
+  if (d.fulltext) attrs.push(`@fulltext(${d.fulltext})`)
+  if (d.vector) attrs.push(`@vector(${d.vector.metric})`)
+  return `    ${key.padEnd(12)} ${type}${attrs.length ? " " + attrs.join(" ") : ""}`
+}
+
+export const toMarci = (metas: Record<string, ModelMeta>): string => {
+  const out: string[] = []
+  const extra: string[] = []
+  for (const meta of Object.values(metas)) {
+    const lines = Object.entries(meta.fields).map(([k, d]) => emitField(meta.name, k, d, extra))
+    out.push(`model ${meta.name} {\n${lines.join("\n")}\n}`)
+  }
+  return [...out, ...extra].join("\n\n") + "\n"
+}
+
+// ───────────────────────────── queries ─────────────────────────────
+
+/**
+ * The model metadata marcidb's query layer reads (`MODELS` in a generated client): field descriptors per
+ * model — `key` / `body` scalars, `one` / `many` relations with their target. Structs are pseudo-models
+ * (`User.info`) so an empty nested select fills with the struct's own scalars, as marcidb does.
+ */
+const modelsMeta = (metas: Record<string, ModelMeta>): ModelsMeta => {
+  const out: Record<string, FieldDesc[]> = {}
+  const describe = (name: string, fields: Record<string, FieldDef>, implicitId: boolean) => {
+    const descs: FieldDesc[] = implicitId ? [{ n: "id", k: "key" }] : []
+    for (const [key, d] of Object.entries(fields)) {
+      if (isRel(d)) descs.push({ n: key, k: d.kind === "one" ? "one" : "many", m: d.model! })
+      else if (d.kind === "struct") {
+        const sub = `${name}.${key}`
+        const inner: Record<string, FieldDef> = {}
+        for (const [ik, f] of Object.entries(d.fields!)) inner[ik] = (f as Field<any, any>).def
+        describe(sub, inner, false)
+        descs.push({ n: key, k: "one", m: sub })
+      }
+      else descs.push({ n: key, k: d.isId ? "key" : "body" })
+    }
+    out[name] = descs
+  }
+  for (const meta of Object.values(metas)) describe(meta.name, meta.fields, meta.idKeys.length === 0)
+  return out
+}
+
+const uncap = (s: string) => s.charAt(0).toLowerCase() + s.slice(1)
+
+export type DefineDbOptions = { transport?: MarciTransport }
+
+/**
+ * The schema registry: model name = key (`db.user` ← `User`). Relation strings are checked against the
+ * keys both at the type level (`ValidateRefs`) and at runtime.
+ */
+/**
+ * The auth models (docs/backend-plan.md §3.4): `auth.model.user()` must be registered as `User`,
+ * `auth.model.session()` as `Session`; `Session` is added when the project doesn't declare it (a device
+ * session exists before any login), and gets its `user` column exactly when a `User` model exists.
+ */
+const withAuthModels = (models: Record<string, Model>): { models: Record<string, Model>, auth: AuthBinding } => {
+  for (const [name, m] of Object.entries(models)) {
+    if (isAuthModel(m, "user") && name !== AUTH_USER_MODEL) throw new Error(`defineDb: auth.model.user() must be registered as "${AUTH_USER_MODEL}" (got "${name}")`)
+    if (isAuthModel(m, "session") && name !== AUTH_SESSION_MODEL) throw new Error(`defineDb: auth.model.session() must be registered as "${AUTH_SESSION_MODEL}" (got "${name}")`)
+  }
+  // A plain `model()` named User is just a model (no auth binding); only auth.model.user() binds.
+  const user = isAuthModel(models[AUTH_USER_MODEL], "user") ? models[AUTH_USER_MODEL] : null
+  let session = models[AUTH_SESSION_MODEL]
+  if (session && !isAuthModel(session, "session")) throw new Error(`defineDb: "${AUTH_SESSION_MODEL}" is reserved for auth.model.session()`)
+  if (!session) session = authSessionModel()
+  if (user && !("user" in session.fields)) session = { ...session, fields: { ...session.fields, user: sessionUserField() } }
+  return { models: { ...models, [AUTH_SESSION_MODEL]: session }, auth: { user: user ? AUTH_USER_MODEL : null, session: AUTH_SESSION_MODEL } }
+}
+
+export const defineDb = <const S extends Schema>(declared: S & ValidateRefs<S>, options: DefineDbOptions = {}): Db<S> => {
+  const { models, auth } = withAuthModels(declared as Record<string, Model>)
+  const metas = buildMeta(models)
+  const transport = () => {
+    const t = options.transport ?? seam.__lecodesDbTransport
+    if (!t) throw new Error("db: no transport — the host must call setDbTransport() before user code runs")
+    return t
+  }
+  // marcidb's own query builder over our metadata; the transport is the only host-specific piece
+  const { collection } = createQueryLayer({
+    models: modelsMeta(metas),
+    run: op => transport().exec(op),
+    // a single uuid key is generated client-side so `insert` needs no id (the .marci says @format(uuid))
+    prepareInsert: (name, data) => (metas[name].uuidId && data?.id == null ? { ...data, id: crypto.randomUUID() } : data),
+  })
+  const db: Record<string, unknown> = {
+    $schema: toMarci(metas),
+    $models: models,
+    $auth: auth,
+    $transaction: async (ops: unknown[]) => transport().batch(ops.map(opOf)),
+  }
+  for (const name of Object.keys(metas)) db[uncap(name)] = collection(name)
+  ;(seam.__lecodesDbs ??= []).push(db as Db<any>)
+  return db as Db<S>
+}

package/runtime/sdk/server/db/fields.ts

@@ -0,0 +1,132 @@
+/**
+ * `t` — field builders for `model({...})`. Each builder returns an immutable `Field` carrying a runtime
+ * `FieldDef` (what `.marci` is emitted from) and two phantom type parameters: the TS value type and a
+ * `FieldMeta` record (kind / optional / default / …) that `defineDb`'s type layer projects into row,
+ * insert, update, select and where types. Chained modifiers return a NEW field (builders are never
+ * mutated), so `const s = t.string(); { a: s, b: s.optional() }` behaves as expected.
+ */
+
+import type { JsonValue } from "./marci/query"
+
+export type ScalarKind = "string" | "int" | "float" | "bool" | "date" | "uuid" | ""
+export type FieldKind = "scalar" | "json" | "enum" | "struct" | "one" | "many" | "list"
+export type OnDelete = "cascade" | "setNull" | "restrict"
+
+/** Phantom metadata — the type-level twin of `FieldDef`. */
+export type FieldMeta = {
+  kind: FieldKind
+  scalar: ScalarKind
+  optional: boolean
+  hasDefault: boolean
+  array: boolean
+  isId: boolean
+  /** Related model name for one/many/list; "" otherwise. */
+  model: string
+}
+
+type DefaultMeta = { kind: "scalar", scalar: "", optional: false, hasDefault: false, array: false, isId: false, model: "" }
+export type Meta<O extends Partial<FieldMeta>> = { [P in keyof FieldMeta]: P extends keyof O ? O[P] : DefaultMeta[P] }
+type SetMeta<M extends FieldMeta, K extends keyof FieldMeta, V> = { [P in keyof FieldMeta]: P extends K ? V : M[P] }
+
+/** Runtime field definition — everything the `.marci` emitter and the runtime need. */
+export type FieldDef = {
+  kind: FieldKind
+  scalar?: ScalarKind
+  optional: boolean
+  unique: boolean
+  index: boolean
+  hasDefault: boolean
+  default?: unknown
+  array: boolean
+  isId: boolean
+  onDelete?: OnDelete
+  fulltext?: "multi" | "english" | "russian"
+  vector?: { size: number, metric: "cosine" | "euclidean" }
+  /** enum */
+  values?: readonly string[]
+  /** struct */
+  fields?: Record<string, Field<any, any>>
+  /** one / many / list */
+  model?: string
+  /** many: the field on the related model that holds the reference (`@bind`); resolved by defineDb when omitted. */
+  back?: string
+}
+
+type DefaultOf<T, M extends FieldMeta> =
+  M["scalar"] extends "date" ? "now" | number : M["array"] extends true ? T[] : T
+
+export interface Field<T, M extends FieldMeta = FieldMeta> {
+  /** phantom (type-level only — never set at runtime) */ readonly __t?: T
+  /** phantom (type-level only — never set at runtime) */ readonly __m?: M
+  readonly def: FieldDef
+  /** Nullable column (`String?`). */
+  optional(): Field<T, SetMeta<M, "optional", true>>
+  /** `@unique` (on a relation: one-to-one). */
+  unique(): Field<T, M>
+  /** `@index` — used by `$where`, `$order`, aggregations. */
+  index(): Field<T, M>
+  /** `@default(...)`; `"now"` on `t.date()` → `now()`. Makes the field optional on insert. */
+  default(value: DefaultOf<T, M>): Field<T, SetMeta<M, "hasDefault", true>>
+  /** Primitive list (`String[]`). */
+  array(): Field<T, SetMeta<M, "array", true>>
+  /** `@id` — primary key (several → composite). A field literally named `id` is the key implicitly. */
+  id(): Field<T, SetMeta<M, "isId", true>>
+  /** Referential policy for `t.one()` (defaults: required → restrict, optional → setNull). */
+  onDelete(policy: OnDelete): Field<T, M>
+  /** `@fulltext(...)` module index on a string field; query with `$search`. */
+  fulltext(lang?: "multi" | "english" | "russian"): Field<T, M>
+  /** `Float[n] @vector(metric)` — nearest-neighbour index; query with `$near`. */
+  vector(size: number, metric?: "cosine" | "euclidean"): Field<T, M>
+}
+
+const create = <T, M extends FieldMeta>(def: FieldDef): Field<T, M> => {
+  const next = (patch: Partial<FieldDef>) => create<any, any>({ ...def, ...patch })
+  return {
+    def,
+    optional: () => next({ optional: true }),
+    unique: () => next({ unique: true }),
+    index: () => next({ index: true }),
+    default: (value: unknown) => next({ hasDefault: true, default: value }),
+    array: () => next({ array: true }),
+    id: () => next({ isId: true }),
+    onDelete: (policy) => next({ onDelete: policy }),
+    fulltext: (lang = "multi") => next({ fulltext: lang }),
+    vector: (size, metric = "cosine") => next({ vector: { size, metric } }),
+  } as Field<T, M>
+}
+
+const base = (kind: FieldKind, extra: Partial<FieldDef> = {}): FieldDef => ({
+  kind, optional: false, unique: false, index: false, hasDefault: false, array: false, isId: false, ...extra,
+})
+
+const scalar = <T, K extends ScalarKind>(scalar: K) =>
+  create<T, Meta<{ kind: "scalar", scalar: K }>>(base("scalar", { scalar }))
+
+export const t = {
+  string: () => scalar<string, "string">("string"),
+  /** 64-bit signed integer. */
+  int:    () => scalar<number, "int">("int"),
+  /** 64-bit float. */
+  float:  () => scalar<number, "float">("float"),
+  bool:   () => scalar<boolean, "bool">("bool"),
+  /** Epoch milliseconds — reads and writes as `number`. */
+  date:   () => scalar<number, "date">("date"),
+  /** UUID string (16 bytes in storage). On an `id` field the runtime generates it on insert. */
+  uuid:   () => scalar<string, "uuid">("uuid"),
+  /** Any JSON value; `J` is TS-only (marcidb stores it schemaless). Filter by dot-path in `$where`. */
+  json:   <J = JsonValue>() => create<J, Meta<{ kind: "json" }>>(base("json")),
+  /** String enum: `t.enum("draft", "published")`. */
+  enum:   <const V extends readonly [string, ...string[]]>(...values: V) =>
+            create<V[number], Meta<{ kind: "enum" }>>(base("enum", { values })),
+  /** Owned nested object (marcidb `struct`): created/updated with the parent, no id of its own. */
+  struct: <F extends Record<string, Field<any, any>>>(fields: F) =>
+            create<F, Meta<{ kind: "struct" }>>(base("struct", { fields })),
+  /** Reference to one row of `model` (by id). Required unless `.optional()`. */
+  one:    <N extends string>(model: N) => create<never, Meta<{ kind: "one", model: N }>>(base("one", { model })),
+  /** Reverse side of a `t.one()` on `model` (the field is inferred when unambiguous). Read-only list. */
+  many:   <N extends string>(model: N, backField?: string) =>
+            create<never, Meta<{ kind: "many", model: N }>>(base("many", { model, back: backField })),
+  /** Ordered relation list stored inline (`@list`) — hand-arranged collections, duplicates allowed. */
+  list:   <N extends string>(model: N) => create<never, Meta<{ kind: "list", model: N }>>(base("list", { model })),
+}
+export type T = typeof t

package/runtime/sdk/server/db/httpTransport.ts

@@ -0,0 +1,93 @@
+/**
+ * `MarciTransport` over marcidb-server's HTTP API (docs/HTTP-API.md in the marci-db repo) — the
+ * transport the runner installs in every project worker (`setDbTransport(marciHttpTransport(url))`).
+ * Host-side code (Bun/Node): uses the platform `fetch`, never the SDK bridge. Mirrors marcidb's own
+ * `httpTransport` (crates/marcidb-ts/src/prefix.js) minus the binary read fast path.
+ *
+ * `baseUrl` = `http://host:port/<db>`; an optional bearer token (marcidb-server `MARCI_TOKEN`) is sent
+ * on every request. Pass `fetch` explicitly when the global one might be monkey-patched by untrusted
+ * code running in the same realm (the runner captures it before evaluating a project bundle).
+ */
+
+import type { MarciOp, MarciTransport } from "./marci/query"
+
+/** A failed marcidb request: `status` is the HTTP status (0 = network failure), `message` its body. */
+export class MarciHttpError extends Error {
+  readonly status: number
+  constructor(status: number, message: string) {
+    super(message)
+    this.name = "MarciHttpError"
+    this.status = status
+  }
+}
+
+export type MarciHttpOptions = {
+  token?: string | null
+  fetch?: typeof fetch
+}
+
+/** `update/:id` and `delete/:id` take the key in the path: a bare value, or `k=v&k2=v2` for composite keys
+ *  (nested ids flatten with dots — `{ chat: { id: 1 } }` → `chat.id=1`). */
+export const encodeMarciId = (id: unknown): string => {
+  if (typeof id === "object" && id !== null) {
+    const parts: string[] = []
+    const walk = (obj: Record<string, unknown>, prefix: string) => {
+      for (const [k, v] of Object.entries(obj)) {
+        const key = prefix ? `${prefix}.${k}` : k
+        if (typeof v === "object" && v !== null) walk(v as Record<string, unknown>, key)
+        else parts.push(`${key}=${encodeURIComponent(String(v))}`)
+      }
+    }
+    walk(id as Record<string, unknown>, "")
+    return parts.join("&")
+  }
+  return encodeURIComponent(String(id))
+}
+
+/** Low-level request helper (also used by the runner's admin calls: `$sync`, `DELETE /:db`). */
+export const marciRequest = async (
+  url: string,
+  init: { method?: string, body?: unknown, rawBody?: string, token?: string | null, fetch?: typeof fetch } = {},
+): Promise<any> => {
+  const f = init.fetch ?? fetch
+  const headers: Record<string, string> = {}
+  if (init.token) headers.authorization = `Bearer ${init.token}`
+  let body: string | undefined
+  if (init.rawBody !== undefined) { body = init.rawBody; headers["content-type"] = "text/plain" }
+  else if (init.body !== undefined) { body = JSON.stringify(init.body); headers["content-type"] = "application/json" }
+  let res: Response
+  try {
+    res = await f(url, { method: init.method ?? "POST", headers, body })
+  } catch (e) {
+    throw new MarciHttpError(0, `marcidb unreachable: ${(e as Error)?.message ?? e}`)
+  }
+  const text = await res.text()
+  if (!res.ok) throw new MarciHttpError(res.status, text || `HTTP ${res.status}`)
+  if (!text) return undefined
+  try { return JSON.parse(text) } catch { return text }
+}
+
+export const marciHttpTransport = (baseUrl: string, options: MarciHttpOptions = {}): MarciTransport => {
+  const url = baseUrl.replace(/\/+$/, "")
+  const call = (path: string, body?: unknown) => marciRequest(`${url}/${path}`, { body, token: options.token, fetch: options.fetch })
+  return {
+    exec(op: MarciOp) {
+      switch (op.action) {
+        case "findMany":   return call(`${op.model}/findMany`, op.query ?? {})
+        case "findFirst":  return call(`${op.model}/findFirst`, op.query ?? {})
+        case "insert":     return call(`${op.model}/insert`, op.data)
+        case "update":     return call(`${op.model}/update/${encodeMarciId(op.id)}`, op.data).then(() => null)
+        // no id in the path — the filter and the payload travel together in the body
+        case "updateMany": return call(`${op.model}/updateMany`, { ...(op.query ?? {}), data: op.data })
+        case "delete":     return call(`${op.model}/delete/${encodeMarciId(op.id)}`).then(() => null)
+        case "deleteMany": return call(`${op.model}/deleteMany`, op.query ?? {})
+        case "count":      return call(`${op.model}/count`, op.query ?? {})
+        case "aggregate":  return call(`${op.model}/aggregate`, op.query ?? {})
+        default: return Promise.reject(new Error(`marcidb: unknown action '${op.action}'`))
+      }
+    },
+    batch(ops: MarciOp[]) {
+      return call("$transaction", ops)
+    },
+  }
+}

package/runtime/sdk/server/db/index.ts

@@ -0,0 +1,7 @@
+// Server-side db layer (phase 0 prototype of docs/backend-plan.md §3.1). Not yet part of inject.ts.
+export { t } from "./fields"
+export type { Field, FieldDef, FieldMeta } from "./fields"
+export { model, defineDb, ref, setDbTransport, toMarci } from "./defineDb"
+export type { DefineDbOptions } from "./defineDb"
+export type { Db, Model, Schema, Row, Id, Insert, Update, Select, Where, Query, QueryObject, Result, Collection, ScalarSelect, Types } from "./types"
+export type { Op, MarciOp, MarciTransport, JsonValue, Sub } from "./marci/query"