@lunora/d1 1.0.0-alpha.7 → 1.0.0-alpha.71

package/dist/packem_shared/D1Client-DA3flo1o.mjs

@@ -1,143 +0,0 @@
-import { drizzle } from 'drizzle-orm/d1';
-
-const STMT_CACHE_CAPACITY = 256;
-const D1_FIRST_UNCONSTRAINED = "first-unconstrained";
-class D1Session {
-  session;
-  /** See {@link D1Client.stmtCache}. Scoped per session. */
-  stmtCache = /* @__PURE__ */ new Map();
-  constructor(session) {
-    this.session = session;
-  }
-  prepare(sql) {
-    const cached = this.stmtCache.get(sql);
-    if (cached) {
-      this.stmtCache.delete(sql);
-      this.stmtCache.set(sql, cached);
-      return cached;
-    }
-    const stmt = this.session.prepare(sql);
-    if (this.stmtCache.size >= STMT_CACHE_CAPACITY) {
-      const oldest = this.stmtCache.keys().next().value;
-      if (oldest !== void 0) {
-        this.stmtCache.delete(oldest);
-      }
-    }
-    this.stmtCache.set(sql, stmt);
-    return stmt;
-  }
-  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters -- T types the result rows for the caller and is forwarded to the prepared statement.
-  async run(sql, ...binds) {
-    return this.prepare(sql).bind(...binds).run();
-  }
-  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters -- T types the result rows for the caller and is forwarded to the prepared statement.
-  async all(sql, ...binds) {
-    return this.prepare(sql).bind(...binds).all();
-  }
-  async first(sql, ...binds) {
-    return this.prepare(sql).bind(...binds).first();
-  }
-  /**
-   * Returns the most recent bookmark known to the session, or `undefined`
-   * when D1 has not issued one yet.
-   */
-  getBookmark() {
-    return this.session.getBookmark() ?? void 0;
-  }
-}
-class D1Client {
-  db;
-  /**
-   * SQL string -> prepared statement. Prepared statements are reusable in
-   * D1; preparing the same SQL twice forces the worker to round-trip the
-   * statement plan. Caching is per-instance so unit-test isolation holds.
-   * Bounded to {@link STMT_CACHE_CAPACITY} via LRU eviction.
-   */
-  stmtCache = /* @__PURE__ */ new Map();
-  /**
-   * Lazily-built drizzle handle over the bare binding. Memoised so a single
-   * `D1Client` reuses the same dialect/session machinery across calls.
-   */
-  drizzleHandle;
-  constructor(database) {
-    this.db = database;
-  }
-  /**
-   * Open a Sessions-API scoped session. Pass the bookmark forwarded by
-   * the client to opt into read-your-writes consistency.
-   *
-   * With no bookmark this is the first request of a session — there is no
-   * prior write to read, so we open with the explicit `"first-unconstrained"`
-   * constraint (Cloudflare's lowest-latency default: the first read may serve
-   * from any replica). Read-your-writes for sequenced requests still flows
-   * through the forwarded bookmark; a caller needing a strongly-consistent
-   * very-first read should pass `"first-primary"` as the bookmark instead.
-   */
-  withSession(bookmark) {
-    const session = this.db.withSession(bookmark ?? D1_FIRST_UNCONSTRAINED);
-    return new D1Session(session);
-  }
-  /**
-   * Prepare a statement, reusing a cached one when the SQL text matches.
-   * `bind()` on a prepared statement returns a new bound statement and
-   * leaves the underlying prepared plan reusable, so cache hits are safe
-   * even when the previous caller already called `.bind(...).run()`.
-   */
-  prepare(sql) {
-    const cached = this.stmtCache.get(sql);
-    if (cached) {
-      this.stmtCache.delete(sql);
-      this.stmtCache.set(sql, cached);
-      return cached;
-    }
-    const stmt = this.db.prepare(sql);
-    if (this.stmtCache.size >= STMT_CACHE_CAPACITY) {
-      const oldest = this.stmtCache.keys().next().value;
-      if (oldest !== void 0) {
-        this.stmtCache.delete(oldest);
-      }
-    }
-    this.stmtCache.set(sql, stmt);
-    return stmt;
-  }
-  /**
-   * Drizzle handle over the bare `env.DB` binding. Used for typed queries
-   * against generated `sqliteTable` schemas; does **not** participate in the
-   * D1 Sessions API (no bookmark pinning). For bookmark-scoped reads, use
-   * {@link drizzleSession} instead.
-   */
-  get drizzle() {
-    if (this.drizzleHandle) {
-      return this.drizzleHandle;
-    }
-    this.drizzleHandle = drizzle(this.db, { logger: false });
-    return this.drizzleHandle;
-  }
-  /**
-   * Drizzle handle scoped to a D1 Sessions-API session. The bookmark, when
-   * supplied, opts into read-your-writes consistency for follow-up reads on
-   * the same session.
-   *
-   * A `D1DatabaseSession` exposes the same `prepare` / `batch` surface
-   * drizzle calls into, so a single `unknown` cast lets us treat the session
-   * as a `D1Database` for driver-construction purposes.
-   */
-  drizzleSession(bookmark) {
-    const session = this.db.withSession(bookmark ?? D1_FIRST_UNCONSTRAINED);
-    return drizzle(session, { logger: false });
-  }
-  /**
-   * Atomic batch over the drizzle d1 driver. Mirrors `db.batch([...])`
-   * exactly; exposed on the client so callers don't need to hold a drizzle
-   * handle just to run a typed batch.
-   */
-  async batch(items) {
-    return this.drizzle.batch(items);
-  }
-  /** Direct access to the underlying binding (advanced use only). */
-  get raw() {
-    return this.db;
-  }
-}
-
-export { D1Client, D1Session };

package/dist/packem_shared/MigrationRunner-BkEwQ-Ya.mjs

@@ -1,149 +0,0 @@
-import { sql } from 'drizzle-orm';
-import { D1Client } from './D1Client-DA3flo1o.mjs';
-
-const TRACKING_TABLE_NAME = "__drizzle_migrations";
-const TRACKING_TABLE_DDL = `CREATE TABLE IF NOT EXISTS ${TRACKING_TABLE_NAME} (id INTEGER PRIMARY KEY AUTOINCREMENT, hash TEXT NOT NULL, created_at NUMERIC)`;
-const WHITESPACE_RE = /\s/u;
-const TRAILING_SEMICOLON_RE = /;\s*$/u;
-const SHA256_HEX_RE = /^[0-9a-f]{64}$/u;
-const assertSingleStatement = (migration) => {
-  const text = migration.sql;
-  let inSingle = false;
-  let inDouble = false;
-  let inLineComment = false;
-  let inBlockComment = false;
-  let seenStatement = false;
-  for (let index = 0; index < text.length; index += 1) {
-    const character = text[index];
-    const next = text[index + 1];
-    if (inLineComment) {
-      if (character === "\n") {
-        inLineComment = false;
-      }
-      continue;
-    }
-    if (inBlockComment) {
-      if (character === "*" && next === "/") {
-        inBlockComment = false;
-        index += 1;
-      }
-      continue;
-    }
-    if (inSingle) {
-      if (character === "'") {
-        if (next === "'") {
-          index += 1;
-        } else {
-          inSingle = false;
-        }
-      }
-      continue;
-    }
-    if (inDouble) {
-      if (character === '"') {
-        if (next === '"') {
-          index += 1;
-        } else {
-          inDouble = false;
-        }
-      }
-      continue;
-    }
-    if (character === "'") {
-      inSingle = true;
-      continue;
-    }
-    if (character === '"') {
-      inDouble = true;
-      continue;
-    }
-    if (character === "-" && next === "-") {
-      inLineComment = true;
-      index += 1;
-      continue;
-    }
-    if (character === "/" && next === "*") {
-      inBlockComment = true;
-      index += 1;
-      continue;
-    }
-    if (character === ";") {
-      seenStatement = true;
-      continue;
-    }
-    if (seenStatement && character !== void 0 && !WHITESPACE_RE.test(character)) {
-      throw new Error(
-        `Migration "${migration.name}" (v${String(migration.version)}) contains more than one SQL statement. Split it into separate migrations — batch() runs them atomically.`
-      );
-    }
-  }
-};
-const hashMigration = async (text) => {
-  const bytes = new TextEncoder().encode(text);
-  const digest = await crypto.subtle.digest("SHA-256", bytes);
-  return [...new Uint8Array(digest)].map((b) => b.toString(16).padStart(2, "0")).join("");
-};
-class MigrationRunner {
-  client;
-  migrations;
-  /**
-   * Accepts either a {@link D1Client} (preferred — gets typed batches +
-   * drizzle handle for free) or a raw `D1DatabaseLike` binding (wrapped on
-   * the caller's behalf so existing `@lunora/cli` callers keep working).
-   */
-  constructor(database, migrations) {
-    this.client = database instanceof D1Client ? database : new D1Client(database);
-    this.migrations = [...migrations].toSorted((a, b) => a.version - b.version);
-    this.assertUniqueVersions();
-    this.assertUniqueSql();
-  }
-  async run() {
-    await this.client.drizzle.run(sql.raw(TRACKING_TABLE_DDL));
-    const appliedRows = await this.client.drizzle.all(sql.raw(`SELECT hash FROM ${TRACKING_TABLE_NAME}`));
-    const appliedHashes = new Set(appliedRows.map((row) => row.hash));
-    const applied = [];
-    const skipped = [];
-    const hashes = await Promise.all(this.migrations.map(async (migration) => hashMigration(migration.sql)));
-    for (const [index, migration] of this.migrations.entries()) {
-      const hash = hashes[index];
-      if (appliedHashes.has(hash)) {
-        skipped.push({ name: migration.name, version: migration.version });
-        continue;
-      }
-      await this.applyOne(migration, hash);
-      applied.push({ name: migration.name, version: migration.version });
-    }
-    return { applied, skipped };
-  }
-  async applyOne(migration, hash) {
-    assertSingleStatement(migration);
-    const statementText = migration.sql.replace(TRAILING_SEMICOLON_RE, "").trim();
-    if (!SHA256_HEX_RE.test(hash)) {
-      throw new Error(`migration "${migration.name}" produced a non-hex hash; refusing to inline into SQL`);
-    }
-    const trackingInsertSql = `INSERT INTO ${TRACKING_TABLE_NAME} (hash, created_at) VALUES ('${hash}', ${String(Date.now())})`;
-    const items = [this.client.drizzle.run(sql.raw(statementText)), this.client.drizzle.run(sql.raw(trackingInsertSql))];
-    await this.client.batch(items);
-  }
-  assertUniqueVersions() {
-    const seen = /* @__PURE__ */ new Set();
-    for (const m of this.migrations) {
-      if (seen.has(m.version)) {
-        throw new Error(`Duplicate migration version ${String(m.version)}`);
-      }
-      seen.add(m.version);
-    }
-  }
-  assertUniqueSql() {
-    const seen = /* @__PURE__ */ new Map();
-    for (const m of this.migrations) {
-      const previousVersion = seen.get(m.sql);
-      if (previousVersion !== void 0) {
-        throw new Error(`Migrations ${String(previousVersion)} and ${String(m.version)} have identical SQL — bump the content, not just the version.`);
-      }
-      seen.set(m.sql, m.version);
-    }
-  }
-}
-
-export { MigrationRunner };

package/dist/packem_shared/createD1CtxDb-BMR8J0dT.mjs

@@ -1,14 +0,0 @@
-import { createSqlCtxDb, readSqlCdcChanges, runSqlAggregateMigrations, runSqlCdcMigration, runSqlGlobalTableMigrations, runSqlRankMigrations, runSqlSearchMigrations, trimSqlCdcChanges } from '@lunora/sql-store';
-export { createSqlCtxDb, decodeGlobalRow } from '@lunora/sql-store';
-import sqliteDialect from './sqliteDialect-DqYnHPuu.mjs';
-
-const createD1ContextDatabase = (options) => createSqlCtxDb({ ...options, dialect: sqliteDialect });
-const runD1GlobalTableMigrations = (exec, schema) => runSqlGlobalTableMigrations(exec, schema, sqliteDialect);
-const runD1AggregateMigrations = (exec, schema) => runSqlAggregateMigrations(exec, schema, sqliteDialect);
-const runD1RankMigrations = (exec, schema) => runSqlRankMigrations(exec, schema, sqliteDialect);
-const runD1SearchMigrations = (exec, schema) => runSqlSearchMigrations(exec, schema, sqliteDialect);
-const runD1CdcMigration = (exec) => runSqlCdcMigration(exec, sqliteDialect);
-const readD1CdcChanges = (exec, options = {}) => readSqlCdcChanges(exec, options, sqliteDialect);
-const trimD1CdcChanges = (exec, throughSeq) => trimSqlCdcChanges(exec, throughSeq, sqliteDialect);
-
-export { createD1ContextDatabase as createD1CtxDb, readD1CdcChanges, runD1AggregateMigrations, runD1CdcMigration, runD1GlobalTableMigrations, runD1RankMigrations, runD1SearchMigrations, trimD1CdcChanges };

package/dist/packem_shared/exportGlobalRows-BGCPm_nA.mjs

@@ -1,122 +0,0 @@
-import { decodeGlobalRow } from '@lunora/sql-store';
-
-const DEFAULT_BATCH_SIZE = 200;
-const quoteIdentifier = (name) => `"${name.replaceAll('"', '""')}"`;
-const selectGlobalTables = (schema, requested) => {
-  const isGlobal = (table) => schema.tables[table]?.shardMode?.kind === "global";
-  if (requested && requested.length > 0) {
-    return requested.filter((name) => isGlobal(name));
-  }
-  return Object.keys(schema.tables).filter((name) => isGlobal(name));
-};
-const decodeRow = (schema, table, row) => {
-  const definition = schema.tables[table];
-  if (!definition) {
-    return { _creationTime: row["_creationTime"], _id: row["id"] };
-  }
-  return decodeGlobalRow(definition, row);
-};
-const exportGlobalRows = async function* (exec, schema, args) {
-  const tables = selectGlobalTables(schema, args.tables);
-  const batchSize = args.batchSize ?? DEFAULT_BATCH_SIZE;
-  for (const table of tables) {
-    let offset = 0;
-    let hasMore = true;
-    while (hasMore) {
-      const rows = await exec.all(`SELECT * FROM ${quoteIdentifier(table)} LIMIT ? OFFSET ?`, [batchSize, offset]);
-      for (const row of rows) {
-        yield { doc: decodeRow(schema, table, row), table };
-      }
-      hasMore = rows.length === batchSize;
-      offset += rows.length;
-    }
-  }
-};
-const validateRow = (schema, table, document) => {
-  const definition = schema.tables[table];
-  if (!definition) {
-    return `unknown table: ${table}`;
-  }
-  for (const [field, validator] of Object.entries(definition.shape)) {
-    const candidate = document[field];
-    const optional = validator.kind === "optional";
-    if (candidate === void 0 && optional) {
-      continue;
-    }
-    const parser = validator.parse;
-    if (typeof parser !== "function") {
-      continue;
-    }
-    try {
-      parser(candidate);
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      return `field "${field}": ${message}`;
-    }
-  }
-  return void 0;
-};
-const explicitIdConflicts = async (writer, exec, table, explicitId) => {
-  try {
-    if (exec) {
-      const probe = await exec.all(`SELECT 1 AS hit FROM ${quoteIdentifier(table)} WHERE "id" = ? LIMIT 1`, [explicitId]);
-      return probe.length > 0;
-    }
-    const existing = await writer.get(explicitId);
-    return existing !== null;
-  } catch {
-    return false;
-  }
-};
-const importOneRow = async (writer, schema, args, row, line) => {
-  const { doc, table } = row;
-  if (schema.tables[table]?.shardMode?.kind !== "global") {
-    return { kind: "skip" };
-  }
-  if (!doc || typeof doc !== "object" || Array.isArray(doc)) {
-    return { error: { code: "BAD_ROW", line, message: "row is missing or malformed `doc`", table }, kind: "error" };
-  }
-  const failure = validateRow(schema, table, doc);
-  if (failure !== void 0) {
-    return { error: { code: "VALIDATION_ERROR", line, message: failure, table }, kind: "error" };
-  }
-  const explicitId = typeof doc["_id"] === "string" ? doc["_id"] : void 0;
-  if (explicitId !== void 0 && await explicitIdConflicts(writer, args.exec, table, explicitId)) {
-    return { kind: "conflict" };
-  }
-  try {
-    await writer.insert(table, doc, { allowExplicitId: true });
-    return { inserted: table, kind: "inserted" };
-  } catch (error) {
-    const code = error.code ?? "INSERT_FAILED";
-    const message = error instanceof Error ? error.message : String(error);
-    return { error: { code, line, message, table }, kind: "error" };
-  }
-};
-const importGlobalRows = async (writer, schema, args) => {
-  const errors = [];
-  const inserted = {};
-  let conflicts = 0;
-  let line = (args.startLine ?? 1) - 1;
-  for (const row of args.rows) {
-    line += 1;
-    const outcome = await importOneRow(writer, schema, args, row, line);
-    switch (outcome.kind) {
-      case "conflict": {
-        conflicts += 1;
-        break;
-      }
-      case "error": {
-        errors.push(outcome.error);
-        break;
-      }
-      case "inserted": {
-        inserted[outcome.inserted] = (inserted[outcome.inserted] ?? 0) + 1;
-        break;
-      }
-    }
-  }
-  return { conflicts, errors, inserted };
-};
-
-export { exportGlobalRows, importGlobalRows, selectGlobalTables };

package/dist/packem_shared/facetGlobalColumn-C6u_WMIY.mjs

@@ -1,142 +0,0 @@
-import { runD1GlobalTableMigrations } from './createD1CtxDb-BMR8J0dT.mjs';
-import { decodeGlobalRow } from '@lunora/sql-store';
-
-const ensureGlobalTables = (exec, schema) => runD1GlobalTableMigrations(exec, schema);
-const DEFAULT_PAGE_SIZE = 50;
-const MAX_PAGE_SIZE = 500;
-const DEFAULT_FACET_LIMIT = 30;
-const MAX_FACET_LIMIT = 200;
-const quoteIdentifier = (name) => `"${name.replaceAll('"', '""')}"`;
-const clamp = (value, min, max) => Math.min(Math.max(value, min), max);
-const INTERNAL_TABLE = /^sqlite_|^_cf_|^d1_|^__cdc|__agg_|__rank_|__fts_/u;
-const isInternalTable = (name) => INTERNAL_TABLE.test(name);
-const SENSITIVE_COLUMN = /password|secret|token|hash|salt|credential/iu;
-const listTableNames = async (exec) => {
-  const rows = await exec.all("SELECT name FROM sqlite_master WHERE type = 'table' ORDER BY name", []);
-  return rows.map((row) => String(row["name"])).filter((name) => !isInternalTable(name));
-};
-const countRows = async (exec, quotedTable, whereSql = "", whereParams = []) => {
-  const rows = await exec.all(`SELECT COUNT(*) AS c FROM ${quotedTable}${whereSql}`, whereParams);
-  return Number(rows[0]?.["c"] ?? 0);
-};
-const physicalColumnName = (schema, table, displayColumn) => schema.tables[table] !== void 0 && displayColumn === "_id" ? "id" : displayColumn;
-const buildEqPredicate = (schema, table, displayColumns, filters) => {
-  if (filters === void 0 || filters.length === 0) {
-    return void 0;
-  }
-  const clauses = [];
-  const params = [];
-  for (const filter of filters) {
-    if (!displayColumns.includes(filter.column)) {
-      throw Object.assign(new Error(`unknown column: ${filter.column}`), { code: "UNKNOWN_COLUMN", name: "LunoraError", status: 404 });
-    }
-    const quoted = quoteIdentifier(physicalColumnName(schema, table, filter.column));
-    if (filter.value === null || filter.value === void 0) {
-      clauses.push(`${quoted} IS NULL`);
-    } else {
-      clauses.push(`${quoted} = ?`);
-      params.push(filter.value);
-    }
-  }
-  return { params, where: clauses.join(" AND ") };
-};
-const decodeRow = (schema, table, row) => {
-  const definition = schema.tables[table];
-  if (definition) {
-    return decodeGlobalRow(definition, row);
-  }
-  const redacted = {};
-  for (const [key, value] of Object.entries(row)) {
-    redacted[key] = value !== null && value !== void 0 && SENSITIVE_COLUMN.test(key) ? "•••" : value;
-  }
-  return redacted;
-};
-const resolveColumns = async (exec, schema, table) => {
-  const definition = schema.tables[table];
-  if (definition) {
-    return ["_id", "_creationTime", ...Object.keys(definition.shape)];
-  }
-  const info = await exec.all(`PRAGMA table_info(${quoteIdentifier(table)})`, []);
-  return info.map((column) => String(column["name"]));
-};
-const resolveReferences = async (exec, schema, table) => {
-  if (schema.tables[table]) {
-    return void 0;
-  }
-  const rows = await exec.all(`PRAGMA foreign_key_list(${quoteIdentifier(table)})`, []);
-  if (rows.length === 0) {
-    return void 0;
-  }
-  const references = {};
-  for (const row of rows) {
-    const from = String(row["from"]);
-    const target = String(row["table"]);
-    references[from] ??= target;
-  }
-  return references;
-};
-const listGlobalTables = async (exec, schema) => {
-  await ensureGlobalTables(exec, schema);
-  const names = await listTableNames(exec);
-  return Promise.all(
-    names.map(async (name) => {
-      return { name, rowCount: await countRows(exec, quoteIdentifier(name)) };
-    })
-  );
-};
-const readGlobalTablePage = async (exec, schema, options) => {
-  const { table } = options;
-  await ensureGlobalTables(exec, schema);
-  const tableNames = await listTableNames(exec);
-  if (!tableNames.includes(table)) {
-    throw Object.assign(new Error(`unknown table: ${table}`), { code: "UNKNOWN_TABLE", name: "LunoraError", status: 404 });
-  }
-  const limit = clamp(Math.trunc(options.limit ?? DEFAULT_PAGE_SIZE), 1, MAX_PAGE_SIZE);
-  const offset = Math.max(0, Math.trunc(options.offset ?? 0));
-  const quoted = quoteIdentifier(table);
-  const columns = await resolveColumns(exec, schema, table);
-  const predicate = buildEqPredicate(schema, table, columns, options.filters);
-  const whereSql = predicate === void 0 ? "" : ` WHERE ${predicate.where}`;
-  const whereParams = predicate?.params ?? [];
-  const total = await countRows(exec, quoted, whereSql, whereParams);
-  const raw = await exec.all(`SELECT * FROM ${quoted}${whereSql} LIMIT ? OFFSET ?`, [...whereParams, limit, offset]);
-  const rows = raw.map((row) => decodeRow(schema, table, row));
-  const references = await resolveReferences(exec, schema, table);
-  return references === void 0 ? { columns, rows, total } : { columns, refs: references, rows, total };
-};
-const facetGlobalColumn = async (exec, schema, options) => {
-  const { column, table } = options;
-  await ensureGlobalTables(exec, schema);
-  const tableNames = await listTableNames(exec);
-  if (!tableNames.includes(table)) {
-    throw Object.assign(new Error(`unknown table: ${table}`), { code: "UNKNOWN_TABLE", name: "LunoraError", status: 404 });
-  }
-  const columns = await resolveColumns(exec, schema, table);
-  if (!columns.includes(column)) {
-    throw Object.assign(new Error(`unknown column: ${column}`), { code: "UNKNOWN_COLUMN", name: "LunoraError", status: 404 });
-  }
-  const quoted = quoteIdentifier(table);
-  const predicate = buildEqPredicate(schema, table, columns, options.filters);
-  const whereSql = predicate === void 0 ? "" : ` WHERE ${predicate.where}`;
-  const whereParams = predicate?.params ?? [];
-  if (schema.tables[table] === void 0 && SENSITIVE_COLUMN.test(column)) {
-    const total = await countRows(exec, quoted, whereSql, whereParams);
-    return { truncated: false, values: total === 0 ? [] : [{ count: total, value: "•••" }] };
-  }
-  const limit = clamp(Math.trunc(options.limit ?? DEFAULT_FACET_LIMIT), 1, MAX_FACET_LIMIT);
-  const physical = quoteIdentifier(physicalColumnName(schema, table, column));
-  const rows = await exec.all(`SELECT ${physical} AS value, COUNT(*) AS count FROM ${quoted}${whereSql} GROUP BY ${physical} ORDER BY count DESC LIMIT ?`, [
-    ...whereParams,
-    limit + 1
-  ]);
-  const truncated = rows.length > limit;
-  const kept = truncated ? rows.slice(0, limit) : rows;
-  return {
-    truncated,
-    values: kept.map((row) => {
-      return { count: Number(row["count"]), value: row["value"] };
-    })
-  };
-};
-
-export { facetGlobalColumn, listGlobalTables, readGlobalTablePage };

package/dist/packem_shared/sqliteDialect-DqYnHPuu.mjs

@@ -1,27 +0,0 @@
-import { sqliteEncode, sqliteDecode } from '@lunora/sql-store';
-import { sql } from 'drizzle-orm';
-import { sqlAffinityForKind } from '../dialect.mjs';
-
-const UNIQUE_VIOLATION_RE = /unique constraint failed/iu;
-const sqliteDialect = {
-  companionTypes: {
-    autoincrementPrimaryKey: "INTEGER PRIMARY KEY AUTOINCREMENT",
-    integer: "INTEGER",
-    key: "TEXT",
-    real: "REAL",
-    text: "TEXT"
-  },
-  columnType: (kind) => sqlAffinityForKind(kind),
-  decode: (value, kind) => sqliteDecode(value, kind),
-  encode: (value) => sqliteEncode(value),
-  frameworkColumns: () => [
-    { name: "id", type: "TEXT PRIMARY KEY" },
-    { name: "_creationTime", type: "REAL NOT NULL" }
-  ],
-  isUniqueViolation: (error) => error instanceof Error && UNIQUE_VIOLATION_RE.test(error.message),
-  name: "sqlite",
-  supportsReturning: true,
-  tableExists: (table) => sql`SELECT name FROM sqlite_master WHERE type = 'table' AND name = ${table}`
-};
-
-export { sqliteDialect as default };