morpho-socket 0.0.0-stage → 0.2.0

package/packages/reply/index.js

@@ -0,0 +1,126 @@
+// @morpho/reply
+//
+// Problem: when Baileys quotes a message that MENTIONS someone, it drops the original contextInfo (the mentions), so the
+// quoted bubble shows a raw @lid/number instead of the person's name. The fix is to build the quote by hand, carrying the
+// original mentions along. Extracted from Morvyn (utils/citar.js + utils/global.js), in production.
+//
+// Also the small "send something as a reply" helpers every bot rewrites: gif, photo, sticker, voice note, reaction, poll.
+//
+//   const reply = require("@morpho/reply")
+//   await reply.reply(sock, jid, msg, "hello")                      // quotes msg, keeps its mentions
+//   await reply.replyGif(sock, jid, msg, videoBuffer, { caption, mentions })
+//   await reply.sendVoice(sock, jid, mp3Buffer, { quoted: msg })    // converts to ogg/opus (needs ffmpeg)
+//   await reply.sendSticker(sock, jid, webpBuffer, { quoted: msg }) // sticker to any chat (quotes only if asked)
+const { toOggOpus } = require("./voice")
+
+const stripDevice = j => (j ? j.replace(/:\d+(?=@)/, "") : null)
+
+const mentionsOf = msg => msg?.message?.extendedTextMessage?.contextInfo?.mentionedJid || []
+const numberOf = j => String(j).split("@")[0].split(":")[0]
+
+// Builds the contextInfo for sock.sendMessage, carrying the quoted message's mentions.
+// Returns null when the message is not an extended text (then Baileys' normal quote is fine).
+function buildQuoteContext(sock, msg, mentions = []) {
+  const inner = msg?.message?.extendedTextMessage
+  if (!inner || !msg?.key) return null
+  const key = msg.key
+  const participant = key.fromMe
+    ? stripDevice(sock.user?.lid || sock.user?.id)
+    : (key.participant || key.remoteJid)
+  return {
+    mentionedJid: mentions,
+    stanzaId: key.id,
+    participant,
+    quotedMessage: {
+      extendedTextMessage: {
+        text: inner.text,
+        contextInfo: { mentionedJid: inner.contextInfo?.mentionedJid || [] }
+      }
+    }
+  }
+}
+
+// Sends ANY content (text, image, ...) quoting `msg`. The manual quote (which keeps the original's mentions) is only used
+// when the original message mentions someone, or with always=true; otherwise it is Baileys' normal quoted.
+function sendQuoted(sock, jid, msg, content, { always } = {}) {
+  const ci = (always || mentionsOf(msg).length) ? buildQuoteContext(sock, msg, content.mentions || []) : null
+  if (!ci) return sock.sendMessage(jid, content, { quoted: msg })
+  return sock.sendMessage(jid, { ...content, contextInfo: ci })
+}
+
+// Text reply quoting `msg`, keeping its mentions (see sendQuoted).
+function replyWithMentions(sock, jid, msg, text, mentions = [], extra = {}) {
+  const { always, ...rest } = extra
+  return sendQuoted(sock, jid, msg, { ...rest, text, mentions }, { always })
+}
+
+// Replies quoting `msg`; if the reply text repeats literally the "@number" of someone the original message mentioned,
+// that person is really mentioned (WhatsApp swaps the number for the name).
+// E.g. someone sends "/chance da @ana virar admin" and the bot answers "...@ana tem 42%..." — without this, the raw
+// number would show in the text; with it, it becomes her name, clickable.
+function reply(sock, jid, msg, text, extra = {}) {
+  if (!msg) return
+  const original = mentionsOf(msg)
+
+  if (original.length && typeof text === "string" && jid === msg.key?.remoteJid) {
+    const cited = original.filter(j => {
+      const n = numberOf(j).replace(/\D/g, "")
+      return n && new RegExp("@" + n + "(?!\\d)").test(text)
+    })
+    if (cited.length) {
+      const { mentions: own = [], ...rest } = extra
+      return replyWithMentions(sock, jid, msg, text, [...new Set([...own, ...cited])], rest)
+    }
+  }
+
+  return sock.sendMessage(jid, { text, ...extra }, { quoted: msg })
+}
+
+// Media quoting the original message (keeps its mentions). If sending fails (corrupt file, media too large...), falls
+// back to a plain text reply instead of staying silent.
+async function replyMedia(sock, jid, msg, content, { text, mentions = [], onError } = {}) {
+  try {
+    const ci = buildQuoteContext(sock, msg, mentions)
+    if (!ci) return await sock.sendMessage(jid, content, { quoted: msg })
+    return await sock.sendMessage(jid, { ...content, contextInfo: ci })
+  } catch (e) {
+    if (onError) onError(e)
+    return replyWithMentions(sock, jid, msg, text ?? "", mentions)
+  }
+}
+
+// GIF = a video with gifPlayback. `video` is a Buffer.
+const replyGif = (sock, jid, msg, video, { caption = "", mentions = [], onError } = {}) =>
+  replyMedia(sock, jid, msg, { video, gifPlayback: true, caption, mentions }, { text: caption, mentions, onError })
+
+const replyImage = (sock, jid, msg, image, { caption = "", mentions = [], onError } = {}) =>
+  replyMedia(sock, jid, msg, { image, caption, mentions }, { text: caption, mentions, onError })
+
+const replySticker = (sock, jid, msg, sticker) => sock.sendMessage(jid, { sticker }, { quoted: msg })
+
+// Sticker (WebP Buffer) to ANY chat. Quotes only when opts.quoted is given (replySticker always quotes).
+//   opts: { quoted, ...extra }   extra goes into the message content (e.g. { contextInfo })
+function sendSticker(sock, jid, sticker, { quoted, ...extra } = {}) {
+  if (!Buffer.isBuffer(sticker) || !sticker.length) throw new Error("sendSticker: sticker must be a non-empty Buffer")
+  return sock.sendMessage(jid, { sticker, ...extra }, quoted ? { quoted } : undefined)
+}
+
+// Voice note (PTT). WhatsApp only plays PTT as ogg/opus, so any other audio is converted first (needs ffmpeg).
+//   opts: { quoted, convert (default: toOggOpus; pass false when the buffer is already ogg/opus), ...extra }
+async function sendVoice(sock, jid, audio, { quoted, convert = toOggOpus, ...extra } = {}) {
+  if (!Buffer.isBuffer(audio)) throw new Error("sendVoice: audio must be a Buffer")
+  const ogg = convert ? await convert(audio) : audio
+  return sock.sendMessage(jid, { audio: ogg, mimetype: "audio/ogg; codecs=opus", ptt: true, ...extra }, quoted ? { quoted } : undefined)
+}
+
+const react = (sock, msg, emoji) => sock.sendMessage(msg.key.remoteJid, { react: { text: emoji, key: msg.key } })
+
+function sendPoll(sock, jid, question, options = [], { selectableCount = 1 } = {}) {
+  if (!options.length) return
+  return sock.sendMessage(jid, { poll: { name: question, values: options, selectableCount } })
+}
+
+module.exports = {
+  buildQuoteContext, sendQuoted, reply, replyWithMentions, replyMedia, replyGif, replyImage, replySticker,
+  sendSticker, sendVoice, react, sendPoll, toOggOpus, mentionsOf, stripDevice
+}

package/packages/reply/package.json

@@ -0,0 +1,7 @@
+{
+  "name": "@morpho/reply",
+  "version": "0.2.0",
+  "description": "Reply on WhatsApp quoting the original message WITHOUT losing its mentions (Baileys drops the quoted contextInfo, which shows a raw @lid/number in the bubble), plus gif/photo/sticker/voice/reaction/poll helpers. Extracted from Morvyn in production.",
+  "main": "index.js",
+  "license": "MIT"
+}

package/packages/reply/voice.js

@@ -0,0 +1,32 @@
+// Audio -> ogg/opus (the only format WhatsApp plays as a voice note). Needs the ffmpeg binary.
+const fs = require("fs")
+const os = require("os")
+const path = require("path")
+const crypto = require("crypto")
+const { spawn } = require("child_process")
+
+// opts: { ffmpeg: "ffmpeg", timeoutMs: 60000 }
+async function toOggOpus(buffer, { ffmpeg = "ffmpeg", timeoutMs = 60_000 } = {}) {
+  if (!Buffer.isBuffer(buffer)) throw new Error("toOggOpus: buffer must be a Buffer")
+
+  // unique names (two audios at the same time don't step on each other) and files always removed at the end
+  const id = crypto.randomBytes(6).toString("hex")
+  const input = path.join(os.tmpdir(), `morpho_in_${id}`)
+  const output = path.join(os.tmpdir(), `morpho_out_${id}.ogg`)
+
+  try {
+    fs.writeFileSync(input, buffer)
+    // stdio ignored: with stderr on "pipe" and nobody reading it, ffmpeg can hang
+    await new Promise((resolve, reject) => {
+      const ff = spawn(ffmpeg, ["-i", input, "-c:a", "libopus", "-ac", "1", "-b:a", "64k", "-vbr", "on", "-y", output], { stdio: "ignore" })
+      const timer = setTimeout(() => { ff.kill("SIGKILL"); reject(new Error("ffmpeg took too long")) }, timeoutMs)
+      ff.on("close", code => { clearTimeout(timer); code === 0 ? resolve() : reject(new Error(`ffmpeg exited with code ${code}`)) })
+      ff.on("error", e => { clearTimeout(timer); reject(e) })
+    })
+    return fs.readFileSync(output)
+  } finally {
+    for (const f of [input, output]) { try { fs.unlinkSync(f) } catch { /* already gone */ } }
+  }
+}
+
+module.exports = { toOggOpus }

package/packages/sent/README.md

@@ -0,0 +1,27 @@
+# morpho-socket/sent
+
+A short memory of **the messages the bot sent** — what Baileys' `getMessage` asks for.
+
+Baileys calls `getMessage` in two situations: re-sending a message the recipient couldn't decrypt, and opening poll votes. With no store, both fail silently.
+
+```js
+const { createSentStore } = require("morpho-socket/sent")
+const sent = createSentStore({ max: 1500, ttlMs: 2 * 3600e3 })
+
+const sock = makeWASocket({ /* … */, getMessage: key => sent.get(key) })
+
+sent.install(sock, {
+  onSent:     (jid, content, result) => { /* a real message left (not edit/delete/react) */ },
+  onIncoming: msg => { /* every message received from others — e.g. to register polls */ },
+})
+```
+
+`install(sock)` wraps `sendMessage` and `relayMessage` (once per socket) so everything that leaves is remembered — including interactive messages sent through `relayMessage`.
+
+| | |
+|---|---|
+| `createSentStore({ max = 1500, ttlMs = 2 h })` | LRU + TTL |
+| `save(key, message)` · `get(key)` · `size()` | manual use |
+| `install(sock, { onSent, onIncoming, log })` | returns the socket |
+
+With [`pool`](../pool), build one store per socket inside `socketConfig`, as shown in the [guide](../../docs/building-a-bot.md#putting-it-together).

package/packages/sent/index.js

@@ -0,0 +1,65 @@
+// @morpho/sent
+//
+// Baileys asks for `getMessage` in two cases: re-sending a message the recipient couldn't decrypt, and opening poll votes.
+// Without a store both fail silently. This keeps what the bot sends (LRU + TTL) and installs itself on the socket.
+//
+//   const sent = createSentStore()
+//   makeWASocket({ getMessage: key => sent.get(key) })
+//   sent.install(sock, { onSent: (jid, content, result) => ..., onIncoming: msg => ... })
+function createSentStore({ max = 1500, ttlMs = 2 * 3600e3 } = {}) {
+  const m = new Map() // id -> { message, t }
+  const store = {
+    save(key, message) {
+      if (!key?.id || !message) return
+      m.delete(key.id)
+      m.set(key.id, { message, t: Date.now() })
+      if (m.size > max) m.delete(m.keys().next().value)
+    },
+    get(key) {
+      const e = m.get(key?.id)
+      if (!e) return undefined
+      if (Date.now() - e.t > ttlMs) { m.delete(key.id); return undefined }
+      return e.message
+    },
+    size: () => m.size,
+
+    // wraps sendMessage/relayMessage to store everything that leaves, once per socket.
+    //   onSent(jid, content, result)  called after a real message was sent (not edit/delete/react)
+    //   onIncoming(msg)               called for every message received from others (e.g. to register polls)
+    install(sock, { onSent, onIncoming, log = () => {} } = {}) {
+      if (sock.__morphoSent) return sock
+      sock.__morphoSent = true
+      const send = sock.sendMessage.bind(sock)
+      sock.sendMessage = async (jid, content, opts) => {
+        const r = await send(jid, content, opts)
+        try {
+          if (r?.key?.id && r.message && !content?.edit && !content?.delete && !content?.react) {
+            store.save(r.key, r.message)
+            onSent?.(jid, content, r)
+          }
+        } catch (e) { log("save-error", e) }
+        return r
+      }
+      if (typeof sock.relayMessage === "function") {
+        const relay = sock.relayMessage.bind(sock)
+        sock.relayMessage = async (jid, message, opts) => {
+          const r = await relay(jid, message, opts)
+          try { if (opts?.messageId) store.save({ id: opts.messageId }, message) } catch { /* cache only */ }
+          return r
+        }
+      }
+      if (onIncoming) {
+        sock.ev.on("messages.upsert", ({ messages }) => {
+          for (const msg of messages || []) {
+            if (!msg?.message || msg.key?.fromMe || !msg.key?.id) continue
+            try { onIncoming(msg) } catch (e) { log("incoming-error", e) }
+          }
+        })
+      }
+      return sock
+    }
+  }
+  return store
+}
+
+module.exports = { createSentStore }

package/packages/sent/package.json

@@ -0,0 +1 @@
+{ "name": "@morpho/sent", "version": "0.1.0", "description": "Short memory of the messages the bot SENT: what Baileys' getMessage asks for to re-send a message the recipient could not open and to open poll votes.", "main": "index.js", "license": "MIT" }

package/packages/store-file/README.md

@@ -0,0 +1,28 @@
+# morpho-socket/store-file
+
+File-based session backend: one folder per session, one JSON file per key — the same idea as Baileys' `useMultiFileAuthState`, behind the [`MorphoAuthStore`](../core) interface.
+
+It exists as a **migration bridge**: start here, then switch to [`store-sqlite`](../store-sqlite) by changing a single line. Nothing else in your bot notices.
+
+```js
+const store = require("morpho-socket/store-file").create({ dir: "./auth" })
+```
+
+Layout on disk:
+
+```
+auth/
+  client-a/
+    creds.json
+    keys/<type>/<id>.json
+```
+
+Session ids, key types and ids are sanitized to `[a-zA-Z0-9_-]` for file names.
+
+| | |
+|---|---|
+| `create({ dir })` | `dir` is required |
+| `listSessions()` | the folders inside `dir` |
+| `deleteSession(id)` | removes the session folder |
+
+This store does not implement `getLid` / `setLid`, so [`jid`](../jid) keeps its LID → number map in memory only. Use `store-sqlite` if you want it to persist.

package/packages/store-file/index.js

@@ -0,0 +1,63 @@
+// @morpho/store-file — guarda cada sessão em uma pasta, um arquivo JSON por chave.
+// Existe como ponte de migração: quem já usa useMultiFileAuthState do Baileys troca pro Morpho
+// sem mudar ONDE o dado mora, só muda COMO ele é acessado. Depois, trocar para @morpho/store-sqlite
+// é mudar uma linha só, sem o resto do código (handler, mensagens, etc.) perceber a diferença.
+const fs = require("fs")
+const path = require("path")
+const { MorphoAuthStore, encode, decode } = require("@morpho/core")
+
+class FileAuthStore extends MorphoAuthStore {
+  constructor({ dir }) {
+    super()
+    if (!dir) throw new Error("FileAuthStore: 'dir' é obrigatório.")
+    this.dir = dir
+  }
+
+  // deixa só [a-zA-Z0-9_-] no nome de arquivo (sessionId, type e id podem ter caractere estranho)
+  _seguro(s) { return String(s).replace(/[^a-zA-Z0-9_-]/g, "_") }
+  _pastaSessao(sessionId) { return path.join(this.dir, this._seguro(sessionId)) }
+  _arqCreds(sessionId) { return path.join(this._pastaSessao(sessionId), "creds.json") }
+  _arqChave(sessionId, type, id) { return path.join(this._pastaSessao(sessionId), "keys", this._seguro(type), `${this._seguro(id)}.json`) }
+
+  async _ler(arq) {
+    try { return decode(fs.readFileSync(arq, "utf8")) } catch (e) { if (e.code === "ENOENT") return null; throw e }
+  }
+  async _escrever(arq, dado) {
+    fs.mkdirSync(path.dirname(arq), { recursive: true })
+    fs.writeFileSync(arq, encode(dado))
+  }
+
+  async readCreds(sessionId) { return this._ler(this._arqCreds(sessionId)) }
+  async writeCreds(sessionId, creds) { return this._escrever(this._arqCreds(sessionId), creds) }
+
+  async readKeys(sessionId, type, ids) {
+    const out = {}
+    for (const id of ids) {
+      const v = await this._ler(this._arqChave(sessionId, type, id))
+      if (v !== null) out[id] = v
+    }
+    return out
+  }
+
+  async writeKeys(sessionId, writes) {
+    for (const type of Object.keys(writes)) {
+      for (const id of Object.keys(writes[type])) {
+        const valor = writes[type][id]
+        const arq = this._arqChave(sessionId, type, id)
+        if (valor === null) fs.rmSync(arq, { force: true }) // sem await: apagar não termina antes da próxima leitura
+        else await this._escrever(arq, valor)
+      }
+    }
+  }
+
+  async deleteSession(sessionId) {
+    fs.rmSync(this._pastaSessao(sessionId), { recursive: true, force: true })
+  }
+
+  async listSessions() {
+    try { return fs.readdirSync(this.dir, { withFileTypes: true }).filter(d => d.isDirectory()).map(d => d.name) }
+    catch (e) { if (e.code === "ENOENT") return []; throw e }
+  }
+}
+
+module.exports = { FileAuthStore, create: opts => new FileAuthStore(opts) }

package/packages/store-file/package.json

@@ -0,0 +1,8 @@
+{
+  "name": "@morpho/store-file",
+  "version": "0.1.0",
+  "description": "Backend de arquivo para o Morpho (ponte de migração, mesma ideia do useMultiFileAuthState do Baileys)",
+  "main": "index.js",
+  "dependencies": { "@morpho/core": "^0.1.0" },
+  "license": "MIT"
+}

package/packages/store-sqlite/README.md

@@ -0,0 +1,25 @@
+# morpho-socket/store-sqlite
+
+Every WhatsApp session in **one `.sqlite` file**, instead of a folder full of loose JSON files per client.
+
+Uses Node's built-in `node:sqlite` (Node ≥ 22.5): no native compilation, no extra dependency. WAL mode is enabled and key batches are written in a transaction.
+
+```js
+const store = require("morpho-socket/store-sqlite").create({ path: "./data/sessions.sqlite" })
+
+const pool = new MorphoPool({ store, initCreds: initAuthCreds })   // see morpho-socket/pool
+```
+
+| | |
+|---|---|
+| `create({ path })` | `path` defaults to `./morpho-auth.sqlite` |
+| `store.listSessions()` | ids of every saved session |
+| `store.deleteSession(id)` | removes the credentials and keys of one session |
+| `store.close()` | closes the database |
+| `store.getLid(lid)` / `store.setLid(lid, number)` | persistent LID → number map used by [`jid`](../jid) |
+
+The LID map is **global, not per session**: a person's LID is the same for every number you run, so deleting or resetting a session does not erase it.
+
+Pass the same store to `createIdentity({ store })` and the map survives restarts. Implements the [`MorphoAuthStore`](../core) interface; swap backends by changing one line.
+
+> `node:sqlite` prints an `ExperimentalWarning` on current Node versions. It is harmless.

package/packages/store-sqlite/index.js

@@ -0,0 +1,98 @@
+// @morpho/store-sqlite — todas as sessões num arquivo .sqlite só, em vez de uma pasta por cliente
+// cheia de arquivo solto (o problema real que o useMultiFileAuthState tem em multi-cliente).
+//
+// Usa o módulo node:sqlite, nativo do Node (>= 22.5), sem dependência externa nem compilação nativa.
+// Se o seu Node for mais antigo, dá pra trocar o `require("node:sqlite")` abaixo por "better-sqlite3"
+// sem mudar mais nada — a classe só usa .prepare()/.run()/.get()/.all(), API bem parecida nas duas.
+const { DatabaseSync } = require("node:sqlite")
+const { MorphoAuthStore, encode, decode } = require("../core")
+
+class SqliteAuthStore extends MorphoAuthStore {
+  constructor({ path = "./morpho-auth.sqlite" } = {}) {
+    super()
+    this.db = new DatabaseSync(path)
+    this.db.exec(`
+      PRAGMA journal_mode = WAL;
+      CREATE TABLE IF NOT EXISTS creds (
+        session_id TEXT PRIMARY KEY,
+        data TEXT NOT NULL
+      );
+      CREATE TABLE IF NOT EXISTS keys (
+        session_id TEXT NOT NULL,
+        type TEXT NOT NULL,
+        id TEXT NOT NULL,
+        data TEXT NOT NULL,
+        PRIMARY KEY (session_id, type, id)
+      );
+      -- mapa LID -> número (@morpho/jid). Global, não por sessão: o LID de uma pessoa é o mesmo pra qualquer bot,
+      -- então apagar/resetar uma sessão NÃO apaga isto.
+      CREATE TABLE IF NOT EXISTS lid_map (
+        lid TEXT PRIMARY KEY,
+        pn TEXT NOT NULL,
+        atualizado INTEGER NOT NULL
+      );
+    `)
+    this._stmt = {
+      getCreds: this.db.prepare("SELECT data FROM creds WHERE session_id = ?"),
+      setCreds: this.db.prepare("INSERT INTO creds (session_id, data) VALUES (?, ?) ON CONFLICT(session_id) DO UPDATE SET data = excluded.data"),
+      delKey: this.db.prepare("DELETE FROM keys WHERE session_id = ? AND type = ? AND id = ?"),
+      setKey: this.db.prepare("INSERT INTO keys (session_id, type, id, data) VALUES (?, ?, ?, ?) ON CONFLICT(session_id, type, id) DO UPDATE SET data = excluded.data"),
+      delSessionCreds: this.db.prepare("DELETE FROM creds WHERE session_id = ?"),
+      delSessionKeys: this.db.prepare("DELETE FROM keys WHERE session_id = ?"),
+      listSessions: this.db.prepare("SELECT DISTINCT session_id FROM creds"),
+      getLid: this.db.prepare("SELECT pn FROM lid_map WHERE lid = ?"),
+      setLid: this.db.prepare("INSERT INTO lid_map (lid, pn, atualizado) VALUES (?, ?, ?) ON CONFLICT(lid) DO UPDATE SET pn = excluded.pn, atualizado = excluded.atualizado")
+    }
+  }
+
+  async readCreds(sessionId) {
+    const row = this._stmt.getCreds.get(sessionId)
+    return row ? decode(row.data) : null
+  }
+
+  async writeCreds(sessionId, creds) {
+    this._stmt.setCreds.run(sessionId, encode(creds))
+  }
+
+  async readKeys(sessionId, type, ids) {
+    if (!ids.length) return {}
+    // IN (?,?,?) dinâmico — node:sqlite não aceita array direto num placeholder só
+    const stmt = this.db.prepare(`SELECT id, data FROM keys WHERE session_id = ? AND type = ? AND id IN (${ids.map(() => "?").join(",")})`)
+    const linhas = stmt.all(sessionId, type, ...ids)
+    const out = {}
+    for (const l of linhas) out[l.id] = decode(l.data)
+    return out
+  }
+
+  async writeKeys(sessionId, writes) {
+    // transação: o Baileys pode mandar dezenas de chaves de uma vez (ex.: sincronização inicial)
+    this.db.exec("BEGIN")
+    try {
+      for (const type of Object.keys(writes)) {
+        for (const id of Object.keys(writes[type])) {
+          const valor = writes[type][id]
+          if (valor === null) this._stmt.delKey.run(sessionId, type, id)
+          else this._stmt.setKey.run(sessionId, type, id, encode(valor))
+        }
+      }
+      this.db.exec("COMMIT")
+    } catch (e) { this.db.exec("ROLLBACK"); throw e }
+  }
+
+  async deleteSession(sessionId) {
+    this._stmt.delSessionCreds.run(sessionId)
+    this._stmt.delSessionKeys.run(sessionId)
+  }
+
+  async listSessions() {
+    return this._stmt.listSessions.all().map(r => r.session_id)
+  }
+
+  // --- mapa LID -> número, usado pelo @morpho/jid (opcional: quem não tem estes métodos só perde a persistência) ---
+  getLid(lid) { return this._stmt.getLid.get(lid)?.pn ?? null }
+  setLid(lid, pn) { this._stmt.setLid.run(lid, pn, Date.now()) }
+
+  close() { this.db.close() }
+}
+
+module.exports = { SqliteAuthStore, create: opts => new SqliteAuthStore(opts) }

package/packages/store-sqlite/package.json

@@ -0,0 +1,9 @@
+{
+  "name": "@morpho/store-sqlite",
+  "version": "0.1.0",
+  "description": "Backend de SQLite para o Morpho: várias sessões num arquivo só, sem pasta cheia de arquivinho.",
+  "main": "index.js",
+  "dependencies": { "@morpho/core": "^0.1.0" },
+  "engines": { "node": ">=22.5.0" },
+  "license": "MIT"
+}