terrascale 0.3.0

package/src/index.js

@@ -0,0 +1,79 @@
+export { createTerraBaseClient, TerraBaseClient } from "./database.js";
+export {
+  terraBaseDiscoveryOrigin,
+  parseTerraBaseRoutingDocument,
+  TerraBaseDiscoveryError,
+  TerraBaseDiscoveryRouter,
+} from "./discovery.js";
+export * from "./schema.js";
+export * from "./sql.js";
+export {
+  terraScaleReleaseBlockers,
+  TerraScaleCapabilityUnavailableError,
+} from "./management-contracts.js";
+export {
+  createDatabaseQuery,
+  DatabaseSubscriptionView,
+  DatabaseSubscriptionError,
+} from "./database-view.js";
+
+/** @typedef {import("./database.js").TerraBaseClientConfig} TerraBaseClientConfig */
+/** @typedef {import("./database.js").PreparedDatabaseCommit} PreparedDatabaseCommit */
+/** @typedef {import("./database.js").DatabaseRequestOptions} DatabaseRequestOptions */
+
+/** @typedef {import("./database-types.js").CanonicalUuid} CanonicalUuid */
+/** @typedef {import("./database-types.js").DatabaseScope} DatabaseScope */
+/** @typedef {import("./database-types.js").CollectionBinding} CollectionBinding */
+/** @typedef {import("./database-types.js").DatabaseValue} DatabaseValue */
+/** @typedef {import("./database-types.js").DatabaseField} DatabaseField */
+/** @typedef {import("./database-types.js").DatabaseObserved} DatabaseObserved */
+/** @typedef {import("./database-types.js").DatabaseEvent} DatabaseEvent */
+/** @typedef {import("./database-types.js").DatabaseAuthority} DatabaseAuthority */
+/** @typedef {import("./database-types.js").DatabaseCondition} DatabaseCondition */
+/** @typedef {import("./database-types.js").DatabaseWriteValue} DatabaseWriteValue */
+/** @typedef {import("./database-types.js").DatabaseWrite} DatabaseWrite */
+/** @typedef {import("./database-types.js").DatabaseTransactionId} DatabaseTransactionId */
+/** @typedef {import("./database-types.js").DatabaseCommit} DatabaseCommit */
+/** @typedef {import("./database-types.js").DatabaseSibling} DatabaseSibling */
+/** @typedef {import("./database-types.js").DatabasePoint} DatabasePoint */
+/** @typedef {import("./database-types.js").DatabaseQueryValue} DatabaseQueryValue */
+/** @typedef {import("./database-types.js").DatabaseQueryPredicate} DatabaseQueryPredicate */
+/** @typedef {import("./database-types.js").DatabaseQuery} DatabaseQuery */
+/** @typedef {import("./database-types.js").DatabaseQueryRow} DatabaseQueryRow */
+/** @typedef {import("./database-types.js").DatabaseQueryPage} DatabaseQueryPage */
+/** @typedef {import("./database-types.js").DatabaseCommitReceipt} DatabaseCommitReceipt */
+/** @typedef {import("./database-types.js").DatabaseTransactionIdentity} DatabaseTransactionIdentity */
+/** @typedef {import("./database-types.js").DatabaseTransactionStatus} DatabaseTransactionStatus */
+/**
+ * @template T
+ * @typedef {import("./database-types.js").DatabaseResult<T>} DatabaseResult
+ */
+/** @typedef {import("./database-types.js").DatabaseSubscriptionRequest} DatabaseSubscriptionRequest */
+/** @typedef {import("./database-types.js").DatabaseSubscriptionEffect} DatabaseSubscriptionEffect */
+/** @typedef {import("./database-types.js").DatabaseSubscriptionGroup} DatabaseSubscriptionGroup */
+/** @typedef {import("./database-types.js").DatabaseSubscriptionResponse} DatabaseSubscriptionResponse */
+
+/** @typedef {import("./discovery.js").TerraBaseRoutingCapability} TerraBaseRoutingCapability */
+/** @typedef {import("./discovery.js").TerraBaseRoutingCapabilities} TerraBaseRoutingCapabilities */
+/** @typedef {import("./discovery.js").TerraBaseRoutingEndpoint} TerraBaseRoutingEndpoint */
+/** @typedef {import("./discovery.js").TerraBaseRoutingDocument} TerraBaseRoutingDocument */
+
+/** @typedef {import("./management-contracts.js").TerraScaleBlockedCapability} TerraScaleBlockedCapability */
+
+/**
+ * @template TValue
+ * @typedef {import("./result.js").TerraScaleResult<TValue>} TerraScaleResult
+ */
+/** @typedef {import("./result.js").TerraScaleError} TerraScaleError */
+/** @typedef {import("./result.js").TerraScaleFailure} TerraScaleFailure */
+/**
+ * @template TValue
+ * @typedef {import("./result.js").TerraScaleSuccess<TValue>} TerraScaleSuccess
+ */
+
+/** @typedef {import("./database-view.js").DatabaseQueryOptions} DatabaseQueryOptions */
+/** @typedef {import("./database-view.js").DatabaseViewBinding} DatabaseViewBinding */
+/** @typedef {import("./database-view.js").DatabaseViewPosition} DatabaseViewPosition */
+/** @typedef {import("./database-view.js").DatabaseViewSnapshot} DatabaseViewSnapshot */
+/** @typedef {import("./database-view.js").DatabaseQueryCallbacks} DatabaseQueryCallbacks */
+/** @typedef {import("./database-view.js").DatabaseQuerySource} DatabaseQuerySource */

package/src/local/authentication.js

@@ -0,0 +1,47 @@
+import { createHash, timingSafeEqual } from "node:crypto";
+
+const MINIMUM_BEARER_TOKEN_LENGTH = 32;
+const MAXIMUM_BEARER_TOKEN_LENGTH = 512;
+const BEARER_TOKEN_PATTERN = /^[A-Za-z0-9._~+\/-]+=*$/u;
+
+/**
+ * @param {unknown} value
+ * @returns {string}
+ */
+export function normalizeLocalBearerToken(value) {
+  if (typeof value !== "string") {
+    throw new TypeError('bearerToken is required when authentication is "required".');
+  }
+  if (
+    value.length < MINIMUM_BEARER_TOKEN_LENGTH
+    || value.length > MAXIMUM_BEARER_TOKEN_LENGTH
+    || !BEARER_TOKEN_PATTERN.test(value)
+  ) {
+    throw new TypeError(
+      `bearerToken must contain between ${MINIMUM_BEARER_TOKEN_LENGTH} and ${MAXIMUM_BEARER_TOKEN_LENGTH} ASCII bearer-token characters.`,
+    );
+  }
+  return value;
+}
+
+/**
+ * @param {string | null} authorization
+ * @param {string} expectedToken
+ * @returns {boolean}
+ */
+export function matchesLocalBearerAuthorization(authorization, expectedToken) {
+  if (authorization === null) {
+    return false;
+  }
+  const match = /^Bearer ([A-Za-z0-9._~+\/-]+=*)$/iu.exec(authorization.trim());
+  if (match === null) {
+    return false;
+  }
+  const candidateToken = match[1];
+  if (candidateToken === undefined) {
+    return false;
+  }
+  const expectedDigest = createHash("sha256").update(expectedToken).digest();
+  const candidateDigest = createHash("sha256").update(candidateToken).digest();
+  return timingSafeEqual(expectedDigest, candidateDigest);
+}

package/src/local/better-auth.js

@@ -0,0 +1,517 @@
+import { randomUUID } from "node:crypto";
+import { createAdapterFactory } from "@better-auth/core/db/adapter";
+/** @import { CleanedWhere, CustomAdapter, DBAdapter, JoinConfig } from "@better-auth/core/db/adapter" */
+/** @import { BetterAuthOptions } from "@better-auth/core" */
+/** @import { TerraScaleSqliteStore } from "./store.js" */
+
+/** @typedef {Record<string, unknown>} Row */
+/**
+ * @typedef {Parameters<
+ *   NonNullable<Parameters<typeof createAdapterFactory>[0]["adapter"]>
+ * >[0]} FactoryConfig
+ */
+/**
+ * @typedef {(
+ *   options: BetterAuthOptions,
+ * ) => DBAdapter<BetterAuthOptions>} LocalBetterAuthAdapterFactory
+ */
+
+/**
+ * Better Auth 1.7.2 over explicitly enabled development SQLite only.
+ *
+ * @param {TerraScaleSqliteStore} store
+ * @returns {LocalBetterAuthAdapterFactory}
+ */
+export function createLocalBetterAuthAdapter(store) {
+  /**
+   * @param {BetterAuthOptions} options
+   * @param {boolean} scoped
+   * @returns {DBAdapter<BetterAuthOptions>}
+   */
+  function make(options, scoped) {
+    /** @type {ReturnType<typeof createAdapterFactory<BetterAuthOptions>>} */
+    const factory = createAdapterFactory({
+      config: {
+        adapterId: "terrascale-local-sqlite",
+        supportsDates: false,
+        supportsJSON: true,
+        supportsArrays: true,
+        supportsBooleans: true,
+        supportsNumericIds: false,
+        supportsUUIDs: true,
+        transaction: async (callback) => {
+          if (scoped)
+            throw new Error("Nested local auth transactions are unavailable.");
+          return store.transactionAsync(async () =>
+            serializedCallback(make(options, true), callback),
+          );
+        },
+      },
+      adapter: (config) => customAdapter(store, config, scoped),
+    });
+    return factory(options);
+  }
+  return (options) => make(options, false);
+}
+
+/**
+ * @param {TerraScaleSqliteStore} store
+ * @param {FactoryConfig} config
+ * @param {boolean} scoped
+ * @returns {CustomAdapter}
+ */
+function customAdapter(store, config, scoped) {
+  /**
+   * @param {string} model
+   * @returns {Row[]}
+   */
+  const rows = (model) => store.list("local-auth", model);
+  /**
+   * @param {string} model
+   * @param {readonly CleanedWhere[]} clauses
+   * @returns {readonly CleanedWhere[]}
+   */
+  const where = (model, clauses) =>
+    clauses.map((clause) => ({
+      ...clause,
+      field: config.getFieldName({ model, field: clause.field }),
+    }));
+  /**
+   * @param {string} model
+   * @param {readonly CleanedWhere[]} [clauses]
+   * @returns {Row[]}
+   */
+  const find = (model, clauses = []) =>
+    rows(model).filter((row) => matches(row, where(model, clauses)));
+  /**
+   * @param {string} model
+   * @returns {readonly (readonly string[])[]}
+   */
+  const indexes = (model) =>
+    /** @type {readonly (readonly string[])[] | undefined} */ (
+      store.getMeta(`local-auth-indexes:${model}`)
+    ) ?? [["id"]];
+  /** @returns {void} */
+  const installSchema = () => {
+    for (const [model, table] of Object.entries(config.schema)) {
+      const fields = [
+        ["id"],
+        ...Object.entries(table.fields)
+          .filter(([, field]) => field.unique === true)
+          .map(([field]) => [config.getFieldName({ model, field })]),
+        ...(table.indexes ?? [])
+          .filter((index) => index.unique === true)
+          .map((index) =>
+            index.fields.map((field) => config.getFieldName({ model, field })),
+          ),
+      ];
+      const name = config.getModelName(model);
+      const prior = indexes(name);
+      const merged = [...prior];
+      for (const index of fields)
+        if (
+          !merged.some(
+            (value) => JSON.stringify(value) === JSON.stringify(index),
+          )
+        )
+          merged.push(index);
+      for (const row of rows(name)) ensureUnique(name, row, merged);
+      store.setMeta(`local-auth-indexes:${name}`, merged);
+    }
+  };
+  /**
+   * @param {string} model
+   * @param {Row} candidate
+   * @param {readonly (readonly string[])[]} [constraints]
+   * @returns {void}
+   */
+  const ensureUnique = (model, candidate, constraints = indexes(model)) => {
+    for (const other of rows(model)) {
+      if (other.id === candidate.id) continue;
+      for (const fields of constraints) {
+        if (
+          fields.every(
+            (field) =>
+              candidate[field] !== null &&
+              candidate[field] !== undefined &&
+              equal(candidate[field], other[field]),
+          )
+        ) {
+          throw new LocalAuthConstraintError();
+        }
+      }
+    }
+  };
+  /**
+   * @param {string} model
+   * @param {Row} input
+   * @param {boolean} [creating]
+   * @returns {Row}
+   */
+  const save = (model, input, creating = false) => {
+    const row = jsonRow(input);
+    const id =
+      typeof row.id === "string" && row.id.length > 0 ? row.id : randomUUID();
+    const candidate = { ...row, id };
+    if (creating && store.get("local-auth", model, id) !== undefined)
+      throw new LocalAuthConstraintError();
+    ensureUnique(model, candidate);
+    store.put("local-auth", model, id, candidate);
+    return candidate;
+  };
+  /**
+   * @template T
+   * @param {() => T} work
+   * @returns {Promise<T>}
+   */
+  const run = async (work) => {
+    const operation = () => {
+      installSchema();
+      return work();
+    };
+    return scoped
+      ? operation()
+      : store.exclusive(() => store.transaction(operation));
+  };
+  /**
+   * @param {string} model
+   * @param {readonly Row[]} selected
+   * @param {readonly string[] | undefined} select
+   * @param {JoinConfig | undefined} join
+   * @returns {Row[]}
+   */
+  const page = (model, selected, select, join) =>
+    selected.map((row) => {
+      const result =
+        select === undefined || select.length === 0
+          ? { ...row }
+          : Object.fromEntries(
+              select
+                .map((field) => config.getFieldName({ model, field }))
+                .filter((field) => Object.hasOwn(row, field))
+                .map((field) => [field, row[field]]),
+            );
+      for (const [output, relation] of Object.entries(join ?? {})) {
+        const related = rows(config.getModelName(output)).filter((candidate) =>
+          equal(candidate[relation.on.to], row[relation.on.from]),
+        );
+        result[output] =
+          relation.relation === "one-to-one"
+            ? (related[0] ?? null)
+            : related.slice(0, bounded(relation.limit ?? 100, 1000));
+      }
+      return result;
+    });
+  return {
+    /**
+     * @template {Record<string, any>} T
+     * @param {Parameters<CustomAdapter["create"]>[0] & { data: T }} input
+     */
+    create: async (input) =>
+      run(() => /** @type {T} */ (save(input.model, input.data, true))),
+    /**
+     * @template T
+     * @param {Parameters<CustomAdapter["update"]>[0] & { update: T }} input
+     */
+    update: async (input) =>
+      /** @type {Promise<T | null>} */ (
+        run(() => {
+          const row = find(input.model, input.where)[0];
+          return row === undefined
+            ? null
+            : save(input.model, { ...row, ...jsonRow(input.update), id: row.id });
+        })
+      ),
+    updateMany: async (input) =>
+      run(() => {
+        const selected = find(input.model, input.where);
+        for (const row of selected)
+          save(input.model, { ...row, ...input.update, id: row.id });
+        return selected.length;
+      }),
+    /**
+     * @template T
+     * @param {Parameters<CustomAdapter["findOne"]>[0]} input
+     */
+    findOne: async (input) =>
+      /** @type {Promise<T | null>} */ (
+        run(
+          () =>
+            page(
+              input.model,
+              find(input.model, input.where).slice(0, 1),
+              input.select,
+              input.join,
+            )[0] ?? null,
+        )
+      ),
+    /**
+     * @template T
+     * @param {Parameters<CustomAdapter["findMany"]>[0]} input
+     */
+    findMany: async (input) =>
+      /** @type {Promise<T[]>} */ (run(() => {
+        let selected = find(input.model, input.where);
+        if (input.sortBy !== undefined) {
+          const field = config.getFieldName({
+            model: input.model,
+            field: input.sortBy.field,
+          });
+          const direction = input.sortBy.direction === "desc" ? -1 : 1;
+          selected = selected.sort(
+            (left, right) =>
+              compare(left[field], right[field]) * direction ||
+              String(left.id).localeCompare(String(right.id)),
+          );
+        }
+        const offset = bounded(input.offset ?? 0, 1_000_000);
+        return page(
+          input.model,
+          selected.slice(offset, offset + bounded(input.limit, 1000)),
+          input.select,
+          input.join,
+        );
+      })),
+    delete: async (input) =>
+      run(() => {
+        const row = find(input.model, input.where)[0];
+        if (row !== undefined)
+          store.delete("local-auth", input.model, String(row.id));
+      }),
+    deleteMany: async (input) =>
+      run(() => {
+        const selected = find(input.model, input.where);
+        for (const row of selected)
+          store.delete("local-auth", input.model, String(row.id));
+        return selected.length;
+      }),
+    /**
+     * @template T
+     * @param {Parameters<CustomAdapter["consumeOne"]>[0]} input
+     */
+    consumeOne: async (input) =>
+      /** @type {Promise<T | null>} */ (
+        run(() => {
+          const row = find(input.model, input.where)[0];
+          if (row !== undefined)
+            store.delete("local-auth", input.model, String(row.id));
+          return row ?? null;
+        })
+      ),
+    /**
+     * @template T
+     * @param {Parameters<CustomAdapter["incrementOne"]>[0]} input
+     */
+    incrementOne: async (input) =>
+      /** @type {Promise<T | null>} */ (run(() => {
+        const row = find(input.model, input.where)[0];
+        if (row === undefined) return null;
+        /** @type {Row} */
+        const updated = { ...row, ...input.set, id: row.id };
+        for (const [field, delta] of Object.entries(input.increment)) {
+          const name = config.getFieldName({ model: input.model, field });
+          const old = row[name] ?? 0;
+          if (
+            typeof old !== "number" ||
+            !Number.isSafeInteger(old) ||
+            !Number.isSafeInteger(delta) ||
+            !Number.isSafeInteger(old + delta)
+          )
+            throw new TypeError("Local auth counters require safe integers.");
+          updated[name] = old + delta;
+        }
+        return save(input.model, updated);
+      })),
+    count: async (input) => run(() => find(input.model, input.where).length),
+    createSchema: async () =>
+      run(() => ({ code: "local_sqlite_ready", path: store.databasePath })),
+  };
+}
+
+/**
+ * A caught operation failure still poisons the transaction; escaped calls refuse.
+ *
+ * @template T
+ * @param {DBAdapter<BetterAuthOptions>} adapter
+ * @param {(adapter: Omit<DBAdapter<BetterAuthOptions>, "transaction">) => Promise<T>} callback
+ * @returns {Promise<T>}
+ */
+async function serializedCallback(adapter, callback) {
+  let queue = Promise.resolve();
+  let closed = false;
+  /** @type {unknown} */
+  let failure;
+  let failed = false;
+  let count = 0;
+  /** @param {unknown} error */
+  const poison = (error) => {
+    if (!failed) failure = error;
+    failed = true;
+  };
+  const scoped = new Proxy(adapter, {
+    get(target, property, receiver) {
+      if (property === "transaction") return undefined;
+      /** @type {unknown} */
+      const method = Reflect.get(target, property, receiver);
+      if (typeof method !== "function") return method;
+      /** @param {unknown[]} args */
+      return (...args) => {
+        if (closed)
+          return Promise.reject(
+            new Error("Local auth transaction callback has settled."),
+          );
+        if (++count > 100) {
+          const error = new Error(
+            "Local auth transaction exceeds 100 operations.",
+          );
+          poison(error);
+          return Promise.reject(error);
+        }
+        const operation = queue.then(() => {
+          if (failed) throw failure;
+          return /** @type {unknown} */ (Reflect.apply(method, target, args));
+        });
+        queue = operation.then(() => undefined, poison);
+        return operation;
+      };
+    },
+  });
+  /** @type {T | undefined} */
+  let value;
+  try {
+    value = await callback(scoped);
+  } catch (error) {
+    poison(error);
+  } finally {
+    closed = true;
+    await queue;
+  }
+  if (failed) throw failure;
+  return /** @type {T} */ (value);
+}
+
+export class LocalAuthConstraintError extends Error {
+  /** @readonly */
+  code = "unique_conflict";
+  constructor() {
+    super("A unique Better Auth record already exists.");
+    this.name = "LocalAuthConstraintError";
+  }
+}
+/**
+ * @param {number} value
+ * @param {number} maximum
+ * @returns {number}
+ */
+function bounded(value, maximum) {
+  if (!Number.isSafeInteger(value) || value < 0 || value > maximum)
+    throw new TypeError("Local auth pagination exceeds its bound.");
+  return value;
+}
+/**
+ * @param {unknown} input
+ * @returns {Row}
+ */
+function jsonRow(input) {
+  if (input === null || typeof input !== "object" || Array.isArray(input))
+    throw new TypeError("Auth records require objects.");
+  // Official factory handles Date conversion; undefined optional fields are omitted.
+  return /** @type {Row} */ (JSON.parse(JSON.stringify(input)));
+}
+/**
+ * @param {unknown} left
+ * @param {unknown} right
+ * @returns {boolean}
+ */
+function equal(left, right) {
+  return JSON.stringify(left ?? null) === JSON.stringify(right ?? null);
+}
+/**
+ * @param {unknown} left
+ * @param {unknown} right
+ * @returns {number}
+ */
+function compare(left, right) {
+  if (equal(left, right)) return 0;
+  if (typeof left === "number" && typeof right === "number")
+    return left < right ? -1 : 1;
+  return String(left ?? "") < String(right ?? "") ? -1 : 1;
+}
+/**
+ * @param {Row} row
+ * @param {readonly CleanedWhere[]} clauses
+ * @returns {boolean}
+ */
+function matches(row, clauses) {
+  let group = true;
+  let result = false;
+  for (const [index, clause] of clauses.entries()) {
+    if (index > 0 && clause.connector === "OR") {
+      result ||= group;
+      group = true;
+    }
+    let left = row[clause.field] ?? null;
+    /** @type {unknown} */
+    let right = clause.value;
+    if (clause.mode === "insensitive") {
+      if (typeof left === "string") left = left.toLowerCase();
+      right = Array.isArray(right)
+        ? right.map((value) =>
+            typeof value === "string" ? value.toLowerCase() : value,
+          )
+        : typeof right === "string"
+          ? right.toLowerCase()
+          : right;
+    }
+    /** @type {boolean} */
+    let matched;
+    switch (clause.operator ?? "eq") {
+      case "eq":
+        matched = equal(left, right);
+        break;
+      case "ne":
+        matched = !equal(left, right);
+        break;
+      case "lt":
+        matched = left !== null && right !== null && compare(left, right) < 0;
+        break;
+      case "lte":
+        matched = left !== null && right !== null && compare(left, right) <= 0;
+        break;
+      case "gt":
+        matched = left !== null && right !== null && compare(left, right) > 0;
+        break;
+      case "gte":
+        matched = left !== null && right !== null && compare(left, right) >= 0;
+        break;
+      case "in":
+        matched =
+          Array.isArray(right) && right.some((value) => equal(left, value));
+        break;
+      case "not_in":
+        matched =
+          Array.isArray(right) && !right.some((value) => equal(left, value));
+        break;
+      case "contains":
+        matched =
+          typeof left === "string" &&
+          typeof right === "string" &&
+          left.includes(right);
+        break;
+      case "starts_with":
+        matched =
+          typeof left === "string" &&
+          typeof right === "string" &&
+          left.startsWith(right);
+        break;
+      case "ends_with":
+        matched =
+          typeof left === "string" &&
+          typeof right === "string" &&
+          left.endsWith(right);
+        break;
+    }
+    group &&= matched;
+  }
+  return result || group;
+}

package/src/local/cli.js

@@ -0,0 +1,51 @@
+#!/usr/bin/env node
+import { resolve } from "node:path";
+import { parseArgs } from "node:util";
+import { createTerraScaleSqliteRuntime } from "./index.js";
+const { values } = parseArgs({
+  options: {
+    database: { type: "string" },
+    host: { type: "string" },
+    port: { type: "string" },
+    "require-auth": { type: "boolean", default: false },
+    "allow-remote": { type: "boolean", default: false },
+    reset: { type: "boolean", default: false },
+    help: { type: "boolean", short: "h", default: false },
+  },
+});
+if (values.help) {
+  process.stdout.write(
+    "Usage: terrascale-local [--database PATH] [--host HOST] [--port PORT] [--require-auth] [--allow-remote] [--reset]\nExplicit local SQLite development listener for native document requests.\n",
+  );
+} else {
+  const runtime = createTerraScaleSqliteRuntime({
+    sqlite: {
+      enabled: true,
+      databasePath: resolve(values.database ?? ".terrascale/local.sqlite"),
+    },
+    allowRemote: values["allow-remote"],
+    ...(values["require-auth"]
+      ? {
+          authentication: "required",
+          bearerToken: process.env.TERRASCALE_LOCAL_BEARER_TOKEN ?? "",
+        }
+      : {}),
+  });
+  try {
+    if (values.reset) await runtime.reset();
+    const address = await runtime.start({
+      ...(values.host === undefined ? {} : { host: values.host }),
+      port: values.port === undefined ? 0 : Number(values.port),
+    });
+    process.stdout.write(
+      `Local SQLite development listener: ${address.origin}\nScope: ${runtime.scope.tenant}/${runtime.scope.database}/${runtime.scope.shard}\nCollection bindings must be explicitly installed by the local application.\n`,
+    );
+    for (const signal of /** @type {const} */ (["SIGINT", "SIGTERM"]))
+      process.once(signal, () => {
+        void runtime.close().then(() => process.exit(0));
+      });
+  } catch (error) {
+    await runtime.close();
+    throw error;
+  }
+}