terrascale 0.3.0 → 1.0.0

package/src/v1/transport.js

@@ -0,0 +1,324 @@
+// Internal typed transport for the TerraBase v1 client. It is not exported
+// from any package entrypoint: callers reach it only through named operations.
+import { parseV1Error } from "./errors.js";
+import { requireName, requireProject } from "./ids.js";
+import { parseExactJson } from "./json.js";
+import { v1Route, v1RoutePath } from "./routes.js";
+/**
+ * @import { FetchLike } from "../config.js"
+ * @import { TerraBaseV1Error } from "./errors.js"
+ * @import { JsonValue } from "./json.js"
+ * @import { V1Operation } from "./routes.js"
+ */
+
+/** Server request body limit (api-v1.md). */
+export const maximumRequestBytes = 4 * 1024 * 1024;
+// Query budgets count stored JSON before wrappers and serializer escaping.
+const defaultMaximumResponseBytes = 64 * 1024 * 1024;
+const tokenPattern = /^tb_[A-Za-z0-9_-]{43}$/u;
+/**
+ * Resolver input contains no credential. A successful URL is cached for this client/database.
+ * @typedef {{ readonly project: string; readonly database: string; readonly signal?: AbortSignal | undefined }} V1EndpointContext
+ */
+/** @typedef {(context: V1EndpointContext) => string | Promise<string>} V1EndpointResolver */
+/**
+ * Project-scoped C# Documents API client. Supply exactly one of baseUrl or endpointResolver.
+ * URLs must use HTTPS or loopback HTTP. Mutations are never automatically replayed.
+ * @typedef {object} TerraBaseV1ClientConfig
+ * @property {string} project
+ * @property {string} token A tb_ API key; held privately.
+ * @property {string | undefined} [baseUrl]
+ * @property {V1EndpointResolver | undefined} [endpointResolver]
+ * @property {FetchLike | undefined} [fetch]
+ * @property {number | undefined} [maxResponseBytes] Default 64 MiB, including query framing and escaping.
+ */
+
+/**
+ * @typedef {object} V1CallOptions
+ * @property {string} [body]
+ * @property {string} [contentType]
+ * @property {Readonly<Record<string, string>>} [headers] Contract headers only (If-Match, If-None-Match).
+ * @property {URLSearchParams | undefined} [query]
+ * @property {AbortSignal | undefined} [signal]
+ */
+
+/**
+ * @typedef {object} V1CallResult
+ * @property {number} status
+ * @property {Headers} headers
+ * @property {JsonValue | undefined} value
+ */
+
+/**
+ * @param {string} host
+ * @returns {boolean}
+ */
+function isLoopbackHost(host) {
+  const name = host.toLowerCase();
+  return (
+    name === "localhost" ||
+    name.endsWith(".localhost") ||
+    name === "[::1]" ||
+    isLoopbackIpv4(name)
+  );
+}
+
+/**
+ * A dotted-decimal address in 127.0.0.0/8 with every octet at most 255. An
+ * out-of-range octet would make the URL parser treat the host as a DNS name.
+ * @param {string} name
+ * @returns {boolean}
+ */
+function isLoopbackIpv4(name) {
+  const octets = /^127\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/u.exec(name);
+  return octets !== null && octets.slice(1).every((octet) => Number(octet) <= 255);
+}
+
+/**
+ * @param {string} raw
+ * @param {string} what
+ * @returns {URL}
+ */
+export function requireServiceUrl(raw, what) {
+  /** @type {URL} */
+  let url;
+  if (typeof raw !== "string") throw new TypeError(`${what} must be an absolute URL.`);
+  try {
+    url = new URL(raw);
+  } catch {
+    throw new TypeError(`${what} must be an absolute URL.`);
+  }
+  if (url.username !== "" || url.password !== "" || url.hash !== "")
+    throw new TypeError(`${what} must not carry credentials or a fragment.`);
+  if (
+    url.protocol !== "https:" &&
+    !(url.protocol === "http:" && isLoopbackHost(url.hostname))
+  )
+    throw new TypeError(`${what} must use HTTPS; plain HTTP is allowed only for loopback hosts.`);
+  return url;
+}
+
+/**
+ * An explicitly configured endpoint, with no discovery or hardcoded hosts.
+ * @param {string} baseUrl
+ * @returns {V1EndpointResolver}
+ */
+export function staticBaseUrlResolver(baseUrl) {
+  const base = canonicalBaseUrl(baseUrl);
+  return () => base;
+}
+/** @param {string} raw @returns {string} */
+function canonicalBaseUrl(raw) {
+  const url = requireServiceUrl(raw, "baseUrl");
+  if (url.search !== "") throw new TypeError("baseUrl must not carry a query.");
+  return `${url.origin}${url.pathname.replace(/\/+$/u, "")}`;
+}
+
+/** A response body that failed in transit after its headers arrived. */
+export class BodyTransportError extends Error {
+  /** @param {unknown} cause */
+  constructor(cause) {
+    super("TerraBase response body failed in transit.", { cause });
+    this.name = "BodyTransportError";
+  }
+}
+
+/** Internal transport bound to one data key. */
+export class V1Transport {
+  /** @type {string} */
+  #project;
+  /** @type {V1EndpointResolver} */
+  #resolver;
+  /** @type {Map<string, { promise: Promise<string>; timer: ReturnType<typeof setTimeout>; waiters: number }>} */
+  #bases = new Map();
+  /** @type {string} */
+  #token;
+  /** @type {FetchLike} */
+  #fetch;
+  /** @type {number} */
+  #maxResponseBytes;
+
+  /** @param {TerraBaseV1ClientConfig} config */
+  constructor(config) {
+    if (typeof config !== "object" || config === null) throw new TypeError("TerraBase v1 client config is required.");
+    this.#project = requireProject(config.project);
+    if ((config.baseUrl === undefined) === (config.endpointResolver === undefined))
+      throw new TypeError("Supply exactly one of baseUrl or endpointResolver.");
+    if (config.endpointResolver !== undefined && typeof config.endpointResolver !== "function")
+      throw new TypeError("endpointResolver must be a function.");
+    this.#resolver = config.endpointResolver ?? staticBaseUrlResolver(/** @type {string} */ (config.baseUrl));
+    if (typeof config.token !== "string" || !tokenPattern.test(config.token))
+      throw new TypeError("token must be a tb_ API key with 43 base64url characters.");
+    if ("autoIdempotencyKey" in config || "maxRetries" in config || "resolver" in config)
+      throw new TypeError("Unsupported client configuration member.");
+    const fetchHandler = config.fetch ?? globalThis.fetch?.bind(globalThis);
+    if (typeof fetchHandler !== "function") throw new TypeError("TerraBase v1 client requires a fetch implementation.");
+    const maxResponseBytes = config.maxResponseBytes ?? defaultMaximumResponseBytes;
+    if (!Number.isSafeInteger(maxResponseBytes) || maxResponseBytes < 1)
+      throw new TypeError("maxResponseBytes must be a positive integer.");
+    this.#token = config.token;
+    this.#fetch = fetchHandler;
+    this.#maxResponseBytes = maxResponseBytes;
+  }
+
+  /**
+   * @param {V1Operation} operation
+   * @param {Readonly<Record<string, string>>} params
+   * @param {AbortSignal | undefined} [signal]
+   * @returns {Promise<string>}
+   */
+  async url(operation, params, signal) {
+    signal?.throwIfAborted();
+    const database = requireName("database", params.database);
+    let base = this.#bases.get(database);
+    if (base === undefined) {
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(new DOMException(
+        "TerraBase endpoint resolution timed out after 30 seconds.", "TimeoutError",
+      )), 30_000);
+      /** @type {Promise<string>} */
+      const promise = new Promise((resolve, reject) => {
+        controller.signal.addEventListener("abort", () => reject(controller.signal.reason), { once: true });
+        void Promise.resolve().then(() => this.#resolver(Object.freeze({
+          project: this.#project, database, signal: controller.signal,
+        }))).then(canonicalBaseUrl).then(resolve, reject).finally(() => clearTimeout(timer));
+      });
+      base = { promise, timer, waiters: 0 };
+      this.#bases.set(database, base);
+      // A failed resolution is not a session; a later operation may resolve again.
+      void promise.catch(() => { if (this.#bases.get(database) === base) this.#bases.delete(database); });
+    }
+    base.waiters++;
+    if (typeof base.timer === "object") base.timer.ref();
+    try {
+      // Each caller cancels its own wait; one caller cannot abort shared session resolution.
+      const resolved = signal === undefined ? await base.promise : await new Promise((resolve, reject) => {
+        const abort = () => reject(signal.reason);
+        signal.addEventListener("abort", abort, { once: true });
+        void base.promise.then(value => {
+          signal.removeEventListener("abort", abort);
+          resolve(value);
+        }, error => {
+          signal.removeEventListener("abort", abort);
+          reject(error);
+        });
+      });
+      signal?.throwIfAborted();
+      return `${resolved}${v1RoutePath(v1Route(operation), { ...params, project: this.#project })}`;
+    } finally {
+      // Keep Node alive only while callers are waiting for this resolution.
+      if (--base.waiters === 0 && typeof base.timer === "object") base.timer.unref();
+    }
+  }
+
+  /**
+   * Reads a response body as UTF-8 text within the response byte bound. A
+   * connection failure while reading is a BodyTransportError.
+   * @param {Response} response
+   * @returns {Promise<string>}
+   */
+  async readText(response) {
+    const reader = response.body?.getReader();
+    if (reader === undefined) return "";
+    /** @type {Uint8Array[]} */
+    const parts = [];
+    let size = 0;
+    try {
+      while (true) {
+        /** @type {ReadableStreamReadResult<Uint8Array>} */
+        let part;
+        try {
+          part = await reader.read();
+        } catch (error) {
+          throw new BodyTransportError(error);
+        }
+        if (part.done) break;
+        size += part.value.byteLength;
+        if (size > this.#maxResponseBytes)
+          throw new TypeError(`TerraBase response exceeds ${this.#maxResponseBytes} bytes.`);
+        parts.push(part.value);
+      }
+    } catch (error) {
+      void reader.cancel().catch(() => undefined);
+      throw error;
+    } finally {
+      reader.releaseLock();
+    }
+    const bytes = new Uint8Array(size);
+    let offset = 0;
+    for (const part of parts) {
+      bytes.set(part, offset);
+      offset += part.byteLength;
+    }
+    return new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+  }
+
+  /**
+   * Parses a JSON response body exactly.
+   * @param {Response} response
+   * @returns {Promise<JsonValue | undefined>}
+   */
+  async readJson(response) {
+    return V1Transport.#decodeJson(response, await this.readText(response));
+  }
+
+  /**
+   * @param {Response} response
+   * @param {string} text
+   * @returns {JsonValue | undefined}
+   */
+  static #decodeJson(response, text) {
+    if (text === "") return undefined;
+    const mediaType = response.headers.get("content-type")?.split(";", 1)[0]?.trim().toLowerCase();
+    if (mediaType !== "application/json")
+      throw new TypeError(`TerraBase returned ${mediaType ?? "no media type"} instead of application/json.`);
+    return parseExactJson(text);
+  }
+
+  /**
+   * Converts a non-success response to a TerraBaseV1Error.
+   * @param {Response} response
+   * @returns {Promise<TerraBaseV1Error>}
+   */
+  async error(response) {
+    let text = "";
+    try {
+      text = await this.readText(response);
+    } catch {
+      text = "";
+    }
+    return parseV1Error(response.status, response.headers, text);
+  }
+
+  /**
+   * Calls only a named producer route. Redirects and failed mutations are never replayed.
+   * @param {V1Operation} operation
+   * @param {Readonly<Record<string, string>>} params
+   * @param {V1CallOptions} [options]
+   * @returns {Promise<V1CallResult>}
+   */
+  async call(operation, params, options = {}) {
+    const route = v1Route(operation);
+    if (options.body !== undefined && new TextEncoder().encode(options.body).byteLength > maximumRequestBytes)
+      throw new TypeError(`TerraBase request bodies are limited to ${maximumRequestBytes} bytes.`);
+    let url = await this.url(operation, params, options.signal);
+    if (options.query !== undefined && options.query.size > 0) url += `?${options.query}`;
+    const headers = new Headers(options.headers);
+    headers.set("authorization", `Bearer ${this.#token}`);
+    headers.set("accept", route.responseMediaType);
+    if (options.body !== undefined) headers.set("content-type", options.contentType ?? "application/json");
+    /** @type {RequestInit} */
+    const init = { method: route.method, headers, redirect: "manual" };
+    if (options.body !== undefined) init.body = options.body;
+    if (options.signal !== undefined) init.signal = options.signal;
+    const response = await this.#fetch(url, init);
+    if (response.type === "opaqueredirect")
+      throw new TypeError("Fresh shape bootstrap requires server fetch; obtain a handle and snapshot offset with collection.shape() on your server.");
+    if (!route.successStatuses.includes(response.status)) throw await this.error(response);
+    if (response.status === 307) {
+      await response.body?.cancel();
+      return { status: response.status, headers: response.headers, value: undefined };
+    }
+    return { status: response.status, headers: response.headers, value: await this.readJson(response) };
+  }
+}

package/types/database-view.d.ts

@@ -1,4 +1,5 @@
 /**
+ * @deprecated Retired SQLite/Rust subscriptions; use the C# client.
  * Native snapshot/poll source shared by React, Svelte and TanStack.
  * @param {TerraBaseClient} client
  * @param {DatabaseQueryOptions} options
@@ -6,7 +7,7 @@
  */
 export function createDatabaseQuery(client: TerraBaseClient, options: DatabaseQueryOptions): DatabaseQuerySource;
 /**
- * @import { TerraBaseClient } from "./database.js"
+ * @import { TerraBaseClient } from "./local/legacy-client.js"
  * @import {
  *   DatabaseField, DatabasePoint, DatabaseQueryPredicate, DatabaseQueryRow,
  *   DatabaseResult, DatabaseScope, DatabaseSubscriptionRequest,
@@ -172,7 +173,7 @@ export type DatabaseQuerySource = {
     readonly binding: DatabaseViewBinding;
     readonly subscribe: (observer: DatabaseQueryCallbacks, context: ReactiveSubscriptionContext) => () => void;
 };
-import type { TerraBaseClient } from "./database.js";
+import type { TerraBaseClient } from "./local/legacy-client.js";
 import type { DatabaseResult } from "./database-types.js";
 import type { DatabaseSubscriptionRequest } from "./database-types.js";
 import type { DatabaseSubscriptionResponse } from "./database-types.js";

package/types/database.d.ts

@@ -1,98 +1,2 @@
-/**
- * @param {TerraBaseClientConfig} config
- * @returns {TerraBaseClient}
- */
-export function createTerraBaseClient(config: TerraBaseClientConfig): TerraBaseClient;
-/** Current scoped document client. All mutations are server commits in one declared shard. */
-export class TerraBaseClient {
-    /** @param {TerraBaseClientConfig} config */
-    constructor(config: TerraBaseClientConfig);
-    /** @returns {DatabaseScope} */
-    get scope(): DatabaseScope;
-    /**
-     * @param {string} collection
-     * @param {string} document
-     * @param {DatabaseRequestOptions} [options]
-     * @returns {Promise<DatabaseResult<DatabasePoint>>}
-     */
-    read(collection: string, document: string, options?: DatabaseRequestOptions): Promise<DatabaseResult<DatabasePoint>>;
-    /**
-     * @param {string} collection
-     * @param {DatabaseQuery} query
-     * @param {DatabaseRequestOptions} [options]
-     * @returns {Promise<DatabaseResult<DatabaseQueryPage>>}
-     */
-    query(collection: string, query: DatabaseQuery, options?: DatabaseRequestOptions): Promise<DatabaseResult<DatabaseQueryPage>>;
-    /**
-     * @param {string} collection
-     * @param {DatabaseSubscriptionRequest} request
-     * @param {DatabaseRequestOptions} [options]
-     * @returns {Promise<DatabaseResult<DatabaseSubscriptionResponse>>}
-     */
-    subscription(collection: string, request: DatabaseSubscriptionRequest, options?: DatabaseRequestOptions): Promise<DatabaseResult<DatabaseSubscriptionResponse>>;
-    /**
-     * Prepare once and retain this identity for exact retry and durable status resolution.
-     * @param {DatabaseCommit} commit
-     * @returns {Promise<PreparedDatabaseCommit>}
-     */
-    prepareCommit(commit: DatabaseCommit): Promise<PreparedDatabaseCommit>;
-    /**
-     * @param {PreparedDatabaseCommit} prepared
-     * @param {DatabaseRequestOptions} [options]
-     * @returns {Promise<DatabaseResult<DatabaseCommitReceipt>>}
-     */
-    commit(prepared: PreparedDatabaseCommit, options?: DatabaseRequestOptions): Promise<DatabaseResult<DatabaseCommitReceipt>>;
-    /**
-     * Unknown, pending and expired outcomes remain unresolved; an absent document proves no abort.
-     * @param {DatabaseTransactionIdentity} identity
-     * @param {DatabaseRequestOptions} [options]
-     * @returns {Promise<DatabaseResult<DatabaseTransactionStatus>>}
-     */
-    transactionStatus(identity: DatabaseTransactionIdentity, options?: DatabaseRequestOptions): Promise<DatabaseResult<DatabaseTransactionStatus>>;
-    #private;
-}
-/**
- * - `apiKey`: native service key used for authenticated Atlas discovery and the selected regional listener.
- * - `endpoint`: a provisioned direct origin. Omit to use authenticated native Atlas discovery.
- * - `discoveryTimeoutMs`: bounds the canonical Atlas request within the complete operation deadline.
- */
-export type TerraBaseClientConfig = DatabaseScope & {
-    readonly apiKey: string | (() => string | Promise<string>);
-    readonly endpoint?: string;
-    readonly discoveryTimeoutMs?: number;
-    readonly requestTimeoutMs?: number;
-    readonly fetch?: FetchLike;
-};
-export type DatabaseRequestOptions = {
-    readonly signal?: AbortSignal;
-};
-export type PreparedDatabaseCommit = DatabaseTransactionIdentity & {
-    readonly [preparedBrand]: true;
-};
-import type { DatabaseScope } from "./database-types.js";
-import type { DatabasePoint } from "./database-types.js";
-import type { DatabaseResult } from "./database-types.js";
-import type { DatabaseQuery } from "./database-types.js";
-import type { DatabaseQueryPage } from "./database-types.js";
-import type { DatabaseSubscriptionRequest } from "./database-types.js";
-import type { DatabaseSubscriptionResponse } from "./database-types.js";
-import type { DatabaseCommit } from "./database-types.js";
-import type { DatabaseCommitReceipt } from "./database-types.js";
-import type { DatabaseTransactionIdentity } from "./database-types.js";
-import type { DatabaseTransactionStatus } from "./database-types.js";
-import type { FetchLike } from "./config.js";
-/**
- * - `apiKey`: native service key used for authenticated Atlas discovery and the selected regional listener.
- * - `endpoint`: a provisioned direct origin. Omit to use authenticated native Atlas discovery.
- * - `discoveryTimeoutMs`: bounds the canonical Atlas request within the complete operation deadline.
- * @typedef {DatabaseScope & {
- *   readonly apiKey: string | (() => string | Promise<string>);
- *   readonly endpoint?: string;
- *   readonly discoveryTimeoutMs?: number;
- *   readonly requestTimeoutMs?: number;
- *   readonly fetch?: FetchLike;
- * }} TerraBaseClientConfig
- */
-/** @typedef {{ readonly signal?: AbortSignal }} DatabaseRequestOptions */
-declare const preparedBrand: unique symbol;
-export {};
+export type TerraBaseClientConfig = import("./v1/transport.js").TerraBaseV1ClientConfig;
+export { createTerraBaseV1Client as createTerraBaseClient, TerraBaseV1Client as TerraBaseClient } from "./v1/terrabase-v1.js";

package/types/index.d.ts

@@ -1,52 +1,43 @@
-export * from "./schema.js";
-export * from "./sql.js";
-export type TerraBaseClientConfig = import("./database.js").TerraBaseClientConfig;
-export type PreparedDatabaseCommit = import("./database.js").PreparedDatabaseCommit;
-export type DatabaseRequestOptions = import("./database.js").DatabaseRequestOptions;
-export type CanonicalUuid = import("./database-types.js").CanonicalUuid;
-export type DatabaseScope = import("./database-types.js").DatabaseScope;
-export type CollectionBinding = import("./database-types.js").CollectionBinding;
-export type DatabaseValue = import("./database-types.js").DatabaseValue;
-export type DatabaseField = import("./database-types.js").DatabaseField;
-export type DatabaseObserved = import("./database-types.js").DatabaseObserved;
-export type DatabaseEvent = import("./database-types.js").DatabaseEvent;
-export type DatabaseAuthority = import("./database-types.js").DatabaseAuthority;
-export type DatabaseCondition = import("./database-types.js").DatabaseCondition;
-export type DatabaseWriteValue = import("./database-types.js").DatabaseWriteValue;
-export type DatabaseWrite = import("./database-types.js").DatabaseWrite;
-export type DatabaseTransactionId = import("./database-types.js").DatabaseTransactionId;
-export type DatabaseCommit = import("./database-types.js").DatabaseCommit;
-export type DatabaseSibling = import("./database-types.js").DatabaseSibling;
-export type DatabasePoint = import("./database-types.js").DatabasePoint;
-export type DatabaseQueryValue = import("./database-types.js").DatabaseQueryValue;
-export type DatabaseQueryPredicate = import("./database-types.js").DatabaseQueryPredicate;
-export type DatabaseQuery = import("./database-types.js").DatabaseQuery;
-export type DatabaseQueryRow = import("./database-types.js").DatabaseQueryRow;
-export type DatabaseQueryPage = import("./database-types.js").DatabaseQueryPage;
-export type DatabaseCommitReceipt = import("./database-types.js").DatabaseCommitReceipt;
-export type DatabaseTransactionIdentity = import("./database-types.js").DatabaseTransactionIdentity;
-export type DatabaseTransactionStatus = import("./database-types.js").DatabaseTransactionStatus;
-export type DatabaseResult<T> = import("./database-types.js").DatabaseResult<T>;
-export type DatabaseSubscriptionRequest = import("./database-types.js").DatabaseSubscriptionRequest;
-export type DatabaseSubscriptionEffect = import("./database-types.js").DatabaseSubscriptionEffect;
-export type DatabaseSubscriptionGroup = import("./database-types.js").DatabaseSubscriptionGroup;
-export type DatabaseSubscriptionResponse = import("./database-types.js").DatabaseSubscriptionResponse;
-export type TerraBaseRoutingCapability = import("./discovery.js").TerraBaseRoutingCapability;
-export type TerraBaseRoutingCapabilities = import("./discovery.js").TerraBaseRoutingCapabilities;
-export type TerraBaseRoutingEndpoint = import("./discovery.js").TerraBaseRoutingEndpoint;
-export type TerraBaseRoutingDocument = import("./discovery.js").TerraBaseRoutingDocument;
-export type TerraScaleBlockedCapability = import("./management-contracts.js").TerraScaleBlockedCapability;
-export type TerraScaleResult<TValue> = import("./result.js").TerraScaleResult<TValue>;
-export type TerraScaleError = import("./result.js").TerraScaleError;
-export type TerraScaleFailure = import("./result.js").TerraScaleFailure;
-export type TerraScaleSuccess<TValue> = import("./result.js").TerraScaleSuccess<TValue>;
-export type DatabaseQueryOptions = import("./database-view.js").DatabaseQueryOptions;
-export type DatabaseViewBinding = import("./database-view.js").DatabaseViewBinding;
-export type DatabaseViewPosition = import("./database-view.js").DatabaseViewPosition;
-export type DatabaseViewSnapshot = import("./database-view.js").DatabaseViewSnapshot;
-export type DatabaseQueryCallbacks = import("./database-view.js").DatabaseQueryCallbacks;
-export type DatabaseQuerySource = import("./database-view.js").DatabaseQuerySource;
-export { createTerraBaseClient, TerraBaseClient } from "./database.js";
-export { terraBaseDiscoveryOrigin, parseTerraBaseRoutingDocument, TerraBaseDiscoveryError, TerraBaseDiscoveryRouter } from "./discovery.js";
+export { v1Filter } from "./v1/filter.js";
+export { documentIdFor } from "./v1/ids.js";
+export { ExactDecimal } from "./v1/json.js";
+export { staticBaseUrlResolver } from "./v1/transport.js";
+export type TerraBaseV1ClientConfig = import("./v1/transport.js").TerraBaseV1ClientConfig;
+export type V1RequestOptions = import("./v1/terrabase-v1.js").V1RequestOptions;
+export type V1ReadOptions = import("./v1/terrabase-v1.js").V1ReadOptions;
+export type V1WriteOptions = import("./v1/terrabase-v1.js").V1WriteOptions;
+export type V1CreateOptions = import("./v1/terrabase-v1.js").V1CreateOptions;
+export type V1ConditionalWriteOptions = import("./v1/terrabase-v1.js").V1ConditionalWriteOptions;
+export type V1PatchOp = import("./v1/terrabase-v1.js").V1PatchOp;
+export type V1Patch = import("./v1/terrabase-v1.js").V1Patch;
+export type V1SortKey = import("./v1/terrabase-v1.js").V1SortKey;
+export type V1Query = import("./v1/terrabase-v1.js").V1Query;
+export type V1Count = import("./v1/terrabase-v1.js").V1Count;
+export type V1QueryPage = import("./v1/terrabase-v1.js").V1QueryPage;
+export type V1Precondition = import("./v1/terrabase-v1.js").V1Precondition;
+export type V1TransactionOpResult = import("./v1/terrabase-v1.js").V1TransactionOpResult;
+export type V1CountBounds = import("./v1/terrabase-v1.js").V1CountBounds;
+export type V1TransactionResult = import("./v1/terrabase-v1.js").V1TransactionResult;
+export type V1Document = import("./v1/decode.js").V1Document;
+export type V1WriteResult = import("./v1/decode.js").V1WriteResult;
+export type V1Durability = import("./v1/decode.js").V1Durability;
+export type V1Filter = import("./v1/filter.js").V1Filter;
+export type V1Path = import("./v1/filter.js").V1Path;
+export type V1Scalar = import("./v1/filter.js").V1Scalar;
+export type V1JsonValue = import("./v1/json.js").JsonValue;
+export type V1JsonObject = import("./v1/json.js").JsonObject;
+export type V1JsonInput = import("./v1/json.js").JsonInput;
+export type V1JsonInputObject = import("./v1/json.js").JsonInputObject;
+export type V1ShapeRequest = import("./v1/shapes.js").V1ShapeRequest;
+export type V1ShapeChange = import("./v1/shapes.js").V1ShapeChange;
+export type V1ShapeOp = import("./v1/shapes.js").V1ShapeOp;
+export type TerraBaseClientConfig = import("./v1/transport.js").TerraBaseV1ClientConfig;
+export type V1EndpointContext = import("./v1/transport.js").V1EndpointContext;
+export type V1EndpointResolver = import("./v1/transport.js").V1EndpointResolver;
+export type V1CollectionInfo = import("./v1/terrabase-v1.js").V1CollectionInfo;
+export type V1CollectionPage = import("./v1/terrabase-v1.js").V1CollectionPage;
+export type V1CollectionListOptions = import("./v1/terrabase-v1.js").V1CollectionListOptions;
+export type V1ShapePage = import("./v1/shapes.js").V1ShapePage;
+export { createTerraBaseV1Client as createTerraBaseClient, TerraBaseV1Client as TerraBaseClient, createTerraBaseV1Client, TerraBaseV1Client, V1Database, V1Collection, V1Collections, V1Transaction } from "./v1/terrabase-v1.js";
 export { terraScaleReleaseBlockers, TerraScaleCapabilityUnavailableError } from "./management-contracts.js";
-export { createDatabaseQuery, DatabaseSubscriptionView, DatabaseSubscriptionError } from "./database-view.js";
+export { TerraBaseV1Error, V1PreconditionFailedError, V1InvalidKeyError, V1ForbiddenScopeError, V1NotFoundError, V1ErrorCode, isTerraBaseV1Error } from "./v1/errors.js";

package/types/local/index.d.ts

@@ -1,9 +1,10 @@
 /**
+ * @deprecated Retired Rust emulator; use a local TerraBase release.
  * @param {TerraScaleSqliteRuntimeOptions} options
  * @returns {TerraScaleSqliteRuntime}
  */
 export function createTerraScaleSqliteRuntime(options: TerraScaleSqliteRuntimeOptions): TerraScaleSqliteRuntime;
-/** @import { TerraBaseClient, TerraBaseClientConfig } from "../database.js" */
+/** @import { TerraBaseClient, TerraBaseClientConfig } from "./legacy-client.js" */
 /** @import { CollectionBinding, DatabaseScope } from "../database-types.js" */
 /** @typedef {import("./context.js").LocalAuthenticationMode} LocalAuthenticationMode */
 /** @typedef {import("./server.js").LocalServerAddress} LocalServerAddress */
@@ -23,7 +24,8 @@ export function createTerraScaleSqliteRuntime(options: TerraScaleSqliteRuntimeOp
  *   readonly port?: number;
  * }} TerraScaleLocalListenOptions
  */
-/** Explicit Node development backend. Never load this entrypoint in deployment or qualification. */
+/** @deprecated Retired Rust SQLite emulator; use a local TerraBase release binary.
+ * Explicit Node development backend. Never load this entrypoint in deployment or qualification. */
 export class TerraScaleSqliteRuntime {
     /**
      * @param {TerraScaleSqliteRuntimeOptions} options
@@ -90,5 +92,5 @@ export type TerraScaleLocalListenOptions = {
 };
 import type { DatabaseScope } from "../database-types.js";
 import type { CollectionBinding } from "../database-types.js";
-import type { TerraBaseClientConfig } from "../database.js";
-import type { TerraBaseClient } from "../database.js";
+import type { TerraBaseClientConfig } from "./legacy-client.js";
+import type { TerraBaseClient } from "./legacy-client.js";