udbx4ts 0.3.0

package/dist/runtime-browser/index.cjs

@@ -0,0 +1,4101 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/runtime-browser/index.ts
+var runtime_browser_exports = {};
+__export(runtime_browser_exports, {
+  BrowserSqliteDriver: () => BrowserSqliteDriver,
+  createBrowserUdbx: () => createBrowserUdbx,
+  createBrowserWorkerRuntime: () => createBrowserWorkerRuntime,
+  createSqliteWasmAdapter: () => createSqliteWasmAdapter,
+  createUdbxBlob: () => createUdbxBlob,
+  downloadBinaryFile: () => downloadBinaryFile,
+  downloadUdbxFile: () => downloadUdbxFile,
+  exportUdbxToBlob: () => exportUdbxToBlob,
+  importUdbxFromFile: () => importUdbxFromFile,
+  installBrowserWorkerRuntime: () => installBrowserWorkerRuntime,
+  installDefaultBrowserWorkerRuntime: () => installDefaultBrowserWorkerRuntime,
+  installSqliteWasmWorkerRuntime: () => installSqliteWasmWorkerRuntime,
+  isOpfsAvailable: () => isOpfsAvailable,
+  readBlobAsUint8Array: () => readBlobAsUint8Array,
+  resolveBrowserSqlOpenTarget: () => resolveBrowserSqlOpenTarget,
+  saveBinaryWithPickerOrDownload: () => saveBinaryWithPickerOrDownload,
+  saveUdbxToFileHandle: () => saveUdbxToFileHandle,
+  saveUdbxWithPickerOrDownload: () => saveUdbxWithPickerOrDownload,
+  supportsFileSystemAccess: () => supportsFileSystemAccess,
+  writeBinaryToFileHandle: () => writeBinaryToFileHandle
+});
+module.exports = __toCommonJS(runtime_browser_exports);
+
+// src/shared-runtime/rpc/methods.ts
+var RPC_METHODS = {
+  udbxOpen: "udbx.open",
+  udbxClose: "udbx.close",
+  udbxListDatasets: "udbx.listDatasets",
+  udbxGetDatasetInfo: "udbx.getDatasetInfo",
+  udbxExportDatabase: "udbx.exportDatabase",
+  udbxImportDatabase: "udbx.importDatabase",
+  udbxCreatePointDataset: "udbx.createPointDataset",
+  udbxCreateLineDataset: "udbx.createLineDataset",
+  udbxCreateRegionDataset: "udbx.createRegionDataset",
+  udbxCreatePointZDataset: "udbx.createPointZDataset",
+  udbxCreateLineZDataset: "udbx.createLineZDataset",
+  udbxCreateRegionZDataset: "udbx.createRegionZDataset",
+  udbxCreateTabularDataset: "udbx.createTabularDataset",
+  udbxCreateCadDataset: "udbx.createCadDataset",
+  datasetGetFields: "dataset.getFields",
+  datasetGetById: "dataset.getById",
+  datasetList: "dataset.list",
+  datasetInsert: "dataset.insert",
+  datasetInsertMany: "dataset.insertMany",
+  datasetCount: "dataset.count",
+  datasetUpdate: "dataset.update",
+  datasetDelete: "dataset.delete"
+};
+
+// src/runtime-browser/client/BrowserDatasetClient.ts
+var BrowserDatasetClient = class {
+  constructor(transport, info) {
+    this.transport = transport;
+    this.info = info;
+  }
+  async getFields() {
+    return this.transport.request(
+      RPC_METHODS.datasetGetFields,
+      { datasetName: this.info.name }
+    );
+  }
+  async getById(id) {
+    return this.transport.request(RPC_METHODS.datasetGetById, { datasetName: this.info.name, id });
+  }
+  async list(options) {
+    const params = options === void 0 ? { datasetName: this.info.name } : { datasetName: this.info.name, options };
+    return this.transport.request(RPC_METHODS.datasetList, params);
+  }
+  async *iterate(options) {
+    const rows = await this.list(options);
+    for (const row of rows) {
+      yield row;
+    }
+  }
+  async insert(feature) {
+    await this.transport.request(
+      RPC_METHODS.datasetInsert,
+      { datasetName: this.info.name, feature }
+    );
+  }
+  async insertMany(features) {
+    const buffer = [];
+    for await (const feature of features) {
+      buffer.push(feature);
+    }
+    await this.transport.request(RPC_METHODS.datasetInsertMany, {
+      datasetName: this.info.name,
+      features: buffer
+    });
+  }
+  async count() {
+    return this.transport.request(
+      RPC_METHODS.datasetCount,
+      { datasetName: this.info.name }
+    );
+  }
+  async update(id, changes) {
+    await this.transport.request(RPC_METHODS.datasetUpdate, { datasetName: this.info.name, id, changes });
+  }
+  async delete(id) {
+    await this.transport.request(RPC_METHODS.datasetDelete, { datasetName: this.info.name, id });
+  }
+};
+
+// src/runtime-browser/client/BrowserUdbxClient.ts
+var BrowserUdbxClient = class _BrowserUdbxClient {
+  constructor(transport, runtime) {
+    this.transport = transport;
+    __publicField(this, "runtime");
+    this.runtime = runtime;
+  }
+  static async connect(transport, options = {}) {
+    const response = await transport.request(
+      RPC_METHODS.udbxOpen,
+      options
+    );
+    return new _BrowserUdbxClient(transport, response.runtime);
+  }
+  async listDatasets() {
+    return this.transport.request(RPC_METHODS.udbxListDatasets);
+  }
+  async getDataset(name) {
+    const info = await this.transport.request(RPC_METHODS.udbxGetDatasetInfo, { name });
+    if (!info) {
+      return null;
+    }
+    return new BrowserDatasetClient(this.transport, info);
+  }
+  async createPointDataset(name, srid, fields) {
+    return this.createDatasetByMethod(RPC_METHODS.udbxCreatePointDataset, name, srid, fields);
+  }
+  async createLineDataset(name, srid, fields) {
+    return this.createDatasetByMethod(RPC_METHODS.udbxCreateLineDataset, name, srid, fields);
+  }
+  async createRegionDataset(name, srid, fields) {
+    return this.createDatasetByMethod(RPC_METHODS.udbxCreateRegionDataset, name, srid, fields);
+  }
+  async createTabularDataset(name, fields) {
+    const params = {
+      name,
+      ...fields === void 0 ? {} : { fields }
+    };
+    const info = await this.transport.request(RPC_METHODS.udbxCreateTabularDataset, params);
+    return new BrowserDatasetClient(this.transport, info);
+  }
+  async close() {
+    await this.transport.request(RPC_METHODS.udbxClose);
+    await this.transport.close();
+  }
+  async exportDatabase() {
+    return this.transport.request(RPC_METHODS.udbxExportDatabase);
+  }
+  async importDatabase(binary, options = {}) {
+    const params = options.preferOpfs === void 0 ? { binary } : { binary, preferOpfs: options.preferOpfs };
+    await this.transport.request(
+      RPC_METHODS.udbxImportDatabase,
+      params
+    );
+  }
+  async createDatasetByMethod(method, name, srid, fields) {
+    const params = {
+      name,
+      srid,
+      ...fields === void 0 ? {} : { fields }
+    };
+    const info = await this.transport.request(method, params);
+    return new BrowserDatasetClient(this.transport, info);
+  }
+};
+
+// src/runtime-browser/client/BrowserWorkerTransport.ts
+function isRuntimeResponse(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  return "id" in value && "ok" in value;
+}
+function toErrorMessage(response) {
+  return `${response.error.code}: ${response.error.message}`;
+}
+var BrowserWorkerTransport = class {
+  constructor(worker) {
+    this.worker = worker;
+    __publicField(this, "requestId", 0);
+    __publicField(this, "pending", /* @__PURE__ */ new Map());
+    __publicField(this, "onMessage", (event) => {
+      const response = event.data;
+      if (!isRuntimeResponse(response)) {
+        return;
+      }
+      const resolver = this.pending.get(response.id);
+      if (!resolver) {
+        return;
+      }
+      this.pending.delete(response.id);
+      if (response.ok) {
+        resolver.resolve(response.result);
+        return;
+      }
+      resolver.reject(new Error(toErrorMessage(response)));
+    });
+    this.worker.addEventListener("message", this.onMessage);
+  }
+  async request(method, params) {
+    const id = `${Date.now()}-${this.requestId++}`;
+    const request = params === void 0 ? { id, method } : { id, method, params };
+    const promise = new Promise((resolve, reject) => {
+      this.pending.set(id, {
+        resolve: (value) => resolve(value),
+        reject
+      });
+    });
+    this.worker.postMessage(request);
+    return promise;
+  }
+  async close() {
+    this.worker.removeEventListener("message", this.onMessage);
+    for (const [, pending] of this.pending) {
+      pending.reject(new Error("Transport closed before response was received."));
+    }
+    this.pending.clear();
+    this.worker.terminate();
+  }
+};
+
+// src/runtime-browser/sqlite/BrowserSqliteDriver.ts
+function normalizeSqlValues(params) {
+  if (!params) {
+    return [];
+  }
+  return params.map((value) => {
+    if (value instanceof ArrayBuffer) {
+      return new Uint8Array(value);
+    }
+    return value;
+  });
+}
+var BrowserSqliteStatement = class {
+  constructor(adapter) {
+    this.adapter = adapter;
+    __publicField(this, "boundParams");
+  }
+  async bind(params) {
+    this.boundParams = params;
+    await this.adapter.bind(normalizeSqlValues(params));
+  }
+  async step() {
+    return this.adapter.step();
+  }
+  async getRow() {
+    return this.adapter.getRow();
+  }
+  async reset() {
+    await this.adapter.reset();
+    this.boundParams = void 0;
+  }
+  async finalize() {
+    await this.adapter.finalize();
+    this.boundParams = void 0;
+  }
+};
+var BrowserSqliteDriver = class {
+  constructor(adapter) {
+    this.adapter = adapter;
+    __publicField(this, "connection", null);
+    __publicField(this, "transactionDepth", 0);
+  }
+  async open(target) {
+    if (this.connection) {
+      throw new Error("Database is already open.");
+    }
+    this.connection = await this.adapter.open(target);
+  }
+  async close() {
+    if (!this.connection) {
+      return;
+    }
+    await this.connection.close();
+    this.connection = null;
+    this.transactionDepth = 0;
+  }
+  async exec(sql) {
+    await this.assertOpen().exec(sql);
+  }
+  async prepare(sql) {
+    const statement = await this.assertOpen().prepare(sql);
+    return new BrowserSqliteStatement(statement);
+  }
+  async transaction(operation) {
+    const nested = this.transactionDepth > 0;
+    const savepointName = `udbx_sp_${this.transactionDepth}`;
+    if (nested) {
+      await this.exec(`SAVEPOINT ${savepointName}`);
+    } else {
+      await this.exec("BEGIN");
+    }
+    this.transactionDepth += 1;
+    try {
+      const result = await operation();
+      this.transactionDepth -= 1;
+      if (nested) {
+        await this.exec(`RELEASE SAVEPOINT ${savepointName}`);
+      } else {
+        await this.exec("COMMIT");
+      }
+      return result;
+    } catch (error) {
+      this.transactionDepth -= 1;
+      if (nested) {
+        await this.exec(`ROLLBACK TO SAVEPOINT ${savepointName}`);
+        await this.exec(`RELEASE SAVEPOINT ${savepointName}`);
+      } else {
+        await this.exec("ROLLBACK");
+      }
+      throw error;
+    }
+  }
+  async exportDatabase() {
+    const connection = this.assertOpen();
+    if (typeof connection.exportDatabase !== "function") {
+      throw new Error("Database export is not supported by current browser driver.");
+    }
+    return connection.exportDatabase();
+  }
+  async importDatabase(target, binary) {
+    if (typeof this.adapter.importDatabase !== "function") {
+      throw new Error("Database import is not supported by current browser driver.");
+    }
+    await this.adapter.importDatabase(target, binary);
+  }
+  assertOpen() {
+    if (!this.connection) {
+      throw new Error("Database is not open.");
+    }
+    return this.connection;
+  }
+};
+
+// src/runtime-browser/sqlite/createSqliteWasmAdapter.ts
+async function defaultInitSqlite3() {
+  const module2 = await import("@sqlite.org/sqlite-wasm");
+  return module2.default();
+}
+function ensureOpfsSupported(sqlite3) {
+  if (typeof sqlite3.oo1.OpfsDb !== "function") {
+    throw new Error("OPFS VFS is unavailable in current browser runtime.");
+  }
+}
+function toFilename(target) {
+  switch (target.kind) {
+    case "memory":
+      return { filename: ":memory:", flags: "c" };
+    case "file":
+      return { filename: target.path, flags: "c" };
+    case "opfs":
+      return { filename: target.path, flags: "c", vfs: "opfs" };
+    case "buffer":
+      throw new Error("Buffer open target is not supported by sqlite-wasm adapter yet.");
+  }
+}
+var SqliteWasmStatementAdapter = class {
+  constructor(statement) {
+    this.statement = statement;
+  }
+  bind(params) {
+    this.statement.bind(params);
+  }
+  step() {
+    return this.statement.step();
+  }
+  getRow() {
+    return this.statement.get({});
+  }
+  reset() {
+    this.statement.reset();
+  }
+  finalize() {
+    this.statement.finalize();
+  }
+};
+var SqliteWasmConnectionAdapter = class {
+  constructor(sqlite3, db) {
+    this.sqlite3 = sqlite3;
+    this.db = db;
+  }
+  exec(sql) {
+    this.db.exec(sql);
+  }
+  prepare(sql) {
+    return new SqliteWasmStatementAdapter(this.db.prepare(sql));
+  }
+  close() {
+    this.db.close();
+  }
+  exportDatabase() {
+    return this.sqlite3.capi.sqlite3_js_db_export(this.db, "main");
+  }
+};
+function createSqliteWasmAdapter(options = {}) {
+  const initSqlite3 = options.initSqlite3 ?? defaultInitSqlite3;
+  let sqlite3Promise = null;
+  const getSqlite3 = async () => {
+    sqlite3Promise ?? (sqlite3Promise = initSqlite3());
+    return sqlite3Promise;
+  };
+  return {
+    importDatabase: async (target, binary) => {
+      if (target.kind !== "opfs") {
+        throw new Error(
+          "sqlite-wasm adapter currently supports import only for OPFS targets."
+        );
+      }
+      const sqlite3 = await getSqlite3();
+      ensureOpfsSupported(sqlite3);
+      await sqlite3.oo1.OpfsDb.importDb(target.path, binary);
+    },
+    open: async (target) => {
+      const sqlite3 = await getSqlite3();
+      const { filename, flags, vfs } = toFilename(target);
+      if (target.kind === "opfs") {
+        ensureOpfsSupported(sqlite3);
+        return new SqliteWasmConnectionAdapter(
+          sqlite3,
+          new sqlite3.oo1.OpfsDb(filename, flags)
+        );
+      }
+      return new SqliteWasmConnectionAdapter(
+        sqlite3,
+        new sqlite3.oo1.DB(filename, flags, vfs)
+      );
+    }
+  };
+}
+
+// src/runtime-browser/sqlite/resolveBrowserSqlOpenTarget.ts
+function isOpfsAvailable(probe = globalThis) {
+  return typeof probe.navigator?.storage?.getDirectory === "function";
+}
+function resolveBrowserSqlOpenTarget(options = {}) {
+  const capabilities = options.capabilities ?? {
+    hasOpfs: isOpfsAvailable(options.capabilityProbe)
+  };
+  const preferOpfs = options.preferOpfs ?? true;
+  if (preferOpfs && capabilities.hasOpfs) {
+    return {
+      kind: "opfs",
+      path: options.opfsPath ?? "udbx/default.udbx"
+    };
+  }
+  if (options.memoryName === void 0) {
+    return { kind: "memory" };
+  }
+  return {
+    kind: "memory",
+    name: options.memoryName
+  };
+}
+
+// src/core/sql/SqlHelpers.ts
+async function queryAll(driver, sql, params) {
+  const statement = await driver.prepare(sql);
+  try {
+    if (params) {
+      await statement.bind(params);
+    }
+    const rows = [];
+    while (await statement.step()) {
+      rows.push(await statement.getRow());
+    }
+    return rows;
+  } finally {
+    await statement.finalize();
+  }
+}
+async function queryOne(driver, sql, params) {
+  const rows = await queryAll(driver, sql, params);
+  return rows[0] ?? null;
+}
+async function executeStatement(statement, params) {
+  try {
+    if (params) {
+      await statement.bind(params);
+    }
+    await statement.step();
+  } finally {
+    await statement.finalize();
+  }
+}
+async function executeSql(driver, sql, params) {
+  const statement = await driver.prepare(sql);
+  await executeStatement(statement, params);
+}
+
+// src/core/schema/UdbxTypeMappings.ts
+var datasetKindToValueMap = {
+  tabular: 0,
+  point: 1,
+  line: 3,
+  region: 5,
+  pointZ: 101,
+  lineZ: 103,
+  regionZ: 105,
+  text: 7,
+  cad: 149
+};
+var datasetValueToKindMap = new Map(
+  Object.entries(datasetKindToValueMap).map(([kind, value]) => [
+    value,
+    kind
+  ])
+);
+var fieldTypeToValueMap = {
+  boolean: 1,
+  byte: 2,
+  int16: 3,
+  int32: 4,
+  int64: 5,
+  single: 6,
+  double: 7,
+  date: 8,
+  binary: 9,
+  geometry: 10,
+  char: 11,
+  ntext: 127,
+  text: 128,
+  time: 16
+};
+var fieldValueToTypeMap = /* @__PURE__ */ new Map([
+  [1, "boolean"],
+  [2, "byte"],
+  [3, "int16"],
+  [4, "int32"],
+  [5, "int64"],
+  [6, "single"],
+  [7, "double"],
+  [8, "date"],
+  [9, "binary"],
+  [10, "geometry"],
+  [11, "char"],
+  [16, "time"],
+  [127, "ntext"],
+  [128, "text"]
+]);
+function datasetKindToValue(kind) {
+  return datasetKindToValueMap[kind];
+}
+function datasetValueToKind(value) {
+  const kind = datasetValueToKindMap.get(value);
+  if (!kind) {
+    throw new Error(`Unsupported SmDatasetType value: ${value}.`);
+  }
+  return kind;
+}
+function fieldTypeToValue(type) {
+  return fieldTypeToValueMap[type];
+}
+function fieldValueToType(value) {
+  const type = fieldValueToTypeMap.get(value);
+  if (!type) {
+    throw new Error(`Unsupported SmFieldType value: ${value}.`);
+  }
+  return type;
+}
+
+// src/core/schema/SmFieldInfoRepository.ts
+function mapRow(row) {
+  return {
+    name: row.SmFieldName,
+    fieldType: fieldValueToType(row.SmFieldType),
+    nullable: row.SmFieldbRequired !== 1,
+    defaultValue: row.SmFieldDefaultValue ?? void 0
+  };
+}
+var SmFieldInfoRepository = class {
+  constructor(driver) {
+    this.driver = driver;
+  }
+  async findByDatasetId(datasetId) {
+    const rows = await queryAll(
+      this.driver,
+      `SELECT
+         SmFieldName,
+         SmFieldType,
+         SmFieldbRequired,
+         SmFieldDefaultValue
+       FROM SmFieldInfo
+       WHERE SmDatasetID = ?
+       ORDER BY SmID`,
+      [datasetId]
+    );
+    return rows.map(mapRow);
+  }
+  async insertAll(datasetId, fields) {
+    for (const field of fields) {
+      const statement = await this.driver.prepare(
+        `INSERT INTO SmFieldInfo (
+           SmDatasetID,
+           SmFieldName,
+           SmFieldType,
+           SmFieldCaption,
+           SmFieldbRequired,
+           SmFieldDefaultValue
+         ) VALUES (?, ?, ?, ?, ?, ?)`
+      );
+      await executeStatement(statement, [
+        datasetId,
+        field.name,
+        fieldTypeToValue(field.fieldType),
+        field.name,
+        field.nullable ? 0 : 1,
+        field.defaultValue == null ? null : String(field.defaultValue)
+      ]);
+    }
+  }
+};
+
+// src/core/dataset/BaseDataset.ts
+var BaseDataset = class {
+  constructor(driver, info) {
+    this.driver = driver;
+    this.info = info;
+    __publicField(this, "fieldInfoRepository");
+    this.fieldInfoRepository = new SmFieldInfoRepository(driver);
+  }
+  getFields() {
+    return this.fieldInfoRepository.findByDatasetId(this.info.id);
+  }
+};
+
+// src/core/utils/errors.ts
+var NotImplementedError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "NotImplementedError";
+  }
+};
+function createNotImplementedError(scope) {
+  return new NotImplementedError(`${scope} is not implemented yet.`);
+}
+
+// src/core/dataset/CadDataset.ts
+var CadDataset = class extends BaseDataset {
+  async getById() {
+    throw createNotImplementedError("CadDataset.getById");
+  }
+  async list() {
+    throw createNotImplementedError("CadDataset.list");
+  }
+  async *iterate() {
+    throw createNotImplementedError("CadDataset.iterate");
+  }
+  async count() {
+    throw createNotImplementedError("CadDataset.count");
+  }
+  async insert() {
+    throw createNotImplementedError("CadDataset.insert");
+  }
+  async insertMany() {
+    throw createNotImplementedError("CadDataset.insertMany");
+  }
+  async update() {
+    throw createNotImplementedError("CadDataset.update");
+  }
+  async delete() {
+    throw createNotImplementedError("CadDataset.delete");
+  }
+};
+
+// src/core/utils/BinaryCursor.ts
+function toUint8Array(input) {
+  if (input instanceof Uint8Array) {
+    return input;
+  }
+  if (ArrayBuffer.isView(input)) {
+    return new Uint8Array(input.buffer, input.byteOffset, input.byteLength);
+  }
+  return new Uint8Array(input);
+}
+var BinaryCursor = class {
+  constructor(input) {
+    __publicField(this, "bytes");
+    __publicField(this, "view");
+    __publicField(this, "offset", 0);
+    this.bytes = toUint8Array(input);
+    this.view = new DataView(
+      this.bytes.buffer,
+      this.bytes.byteOffset,
+      this.bytes.byteLength
+    );
+  }
+  get length() {
+    return this.bytes.byteLength;
+  }
+  get position() {
+    return this.offset;
+  }
+  get remaining() {
+    return this.length - this.offset;
+  }
+  seek(position) {
+    if (position < 0 || position > this.length) {
+      throw new RangeError(
+        `Cannot seek to ${position}; valid range is 0..${this.length}.`
+      );
+    }
+    this.offset = position;
+  }
+  skip(length) {
+    this.seek(this.offset + length);
+  }
+  readUint8() {
+    this.ensureAvailable(1);
+    const value = this.view.getUint8(this.offset);
+    this.offset += 1;
+    return value;
+  }
+  readInt32(littleEndian = true) {
+    this.ensureAvailable(4);
+    const value = this.view.getInt32(this.offset, littleEndian);
+    this.offset += 4;
+    return value;
+  }
+  readFloat64(littleEndian = true) {
+    this.ensureAvailable(8);
+    const value = this.view.getFloat64(this.offset, littleEndian);
+    this.offset += 8;
+    return value;
+  }
+  readBytes(length) {
+    this.ensureAvailable(length);
+    const value = this.bytes.slice(this.offset, this.offset + length);
+    this.offset += length;
+    return value;
+  }
+  peekUint8() {
+    this.ensureAvailable(1);
+    return this.view.getUint8(this.offset);
+  }
+  ensureAvailable(length) {
+    if (length < 0) {
+      throw new RangeError("Length must be non-negative.");
+    }
+    if (this.offset + length > this.length) {
+      throw new RangeError(
+        `Cannot read ${length} byte(s) from offset ${this.offset}; only ${this.remaining} byte(s) remain.`
+      );
+    }
+  }
+};
+
+// src/core/utils/BinaryWriter.ts
+var BinaryWriter = class {
+  constructor(initialCapacity = 64) {
+    __publicField(this, "buffer");
+    __publicField(this, "view");
+    __publicField(this, "bytes");
+    __publicField(this, "offset", 0);
+    if (initialCapacity <= 0) {
+      throw new RangeError("Initial capacity must be greater than 0.");
+    }
+    this.buffer = new ArrayBuffer(initialCapacity);
+    this.view = new DataView(this.buffer);
+    this.bytes = new Uint8Array(this.buffer);
+  }
+  get length() {
+    return this.offset;
+  }
+  writeUint8(value) {
+    this.ensureCapacity(1);
+    this.view.setUint8(this.offset, value);
+    this.offset += 1;
+  }
+  writeInt32(value, littleEndian = true) {
+    this.ensureCapacity(4);
+    this.view.setInt32(this.offset, value, littleEndian);
+    this.offset += 4;
+  }
+  writeFloat64(value, littleEndian = true) {
+    this.ensureCapacity(8);
+    this.view.setFloat64(this.offset, value, littleEndian);
+    this.offset += 8;
+  }
+  writeBytes(value) {
+    const bytes = value instanceof Uint8Array ? value : ArrayBuffer.isView(value) ? new Uint8Array(value.buffer, value.byteOffset, value.byteLength) : new Uint8Array(value);
+    this.ensureCapacity(bytes.byteLength);
+    this.bytes.set(bytes, this.offset);
+    this.offset += bytes.byteLength;
+  }
+  toUint8Array() {
+    return this.bytes.slice(0, this.offset);
+  }
+  ensureCapacity(required) {
+    if (this.offset + required <= this.buffer.byteLength) {
+      return;
+    }
+    let nextCapacity = this.buffer.byteLength;
+    while (this.offset + required > nextCapacity) {
+      nextCapacity *= 2;
+    }
+    const nextBuffer = new ArrayBuffer(nextCapacity);
+    const nextBytes = new Uint8Array(nextBuffer);
+    nextBytes.set(this.bytes.subarray(0, this.offset));
+    this.buffer = nextBuffer;
+    this.view = new DataView(this.buffer);
+    this.bytes = nextBytes;
+  }
+};
+
+// src/core/geometry/gaia/GaiaConstants.ts
+var GAIA_START = 0;
+var GAIA_BYTE_ORDER_LE = 1;
+var GAIA_MBR = 124;
+var GAIA_END = 254;
+var GAIA_GEOMETRY_DATA_OFFSET = 43;
+var GEO_TYPE_POINT = 1;
+var GEO_TYPE_POINTZ = 1001;
+var GEO_TYPE_MULTILINESTRING = 5;
+var GEO_TYPE_MULTILINESTRINGZ = 1005;
+var GEO_TYPE_MULTIPOLYGON = 6;
+var GEO_TYPE_MULTIPOLYGONZ = 1006;
+
+// src/core/geometry/gaia/GaiaErrors.ts
+var GaiaError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "GaiaError";
+  }
+};
+var GaiaFormatError = class extends GaiaError {
+  constructor(message) {
+    super(message);
+    this.name = "GaiaFormatError";
+  }
+};
+var GaiaGeoTypeMismatchError = class extends GaiaError {
+  constructor(expected, actual) {
+    super(`Expected geoType=${expected}, got ${actual}.`);
+    this.name = "GaiaGeoTypeMismatchError";
+  }
+};
+
+// src/core/geometry/gaia/GaiaHeader.ts
+function readGaiaHeader(cursor, expectedGeoType) {
+  cursor.seek(0);
+  const gaiaStart = cursor.readUint8();
+  if (gaiaStart !== GAIA_START) {
+    throw new GaiaFormatError(
+      `Invalid GAIA start marker: expected 0x${GAIA_START.toString(16)}, got 0x${gaiaStart.toString(16)}.`
+    );
+  }
+  const byteOrder = cursor.readUint8();
+  if (byteOrder !== GAIA_BYTE_ORDER_LE) {
+    throw new GaiaFormatError(
+      `Unsupported byte order: expected 0x${GAIA_BYTE_ORDER_LE.toString(16)}, got 0x${byteOrder.toString(16)}.`
+    );
+  }
+  const srid = cursor.readInt32(true);
+  const minX = cursor.readFloat64(true);
+  const minY = cursor.readFloat64(true);
+  const maxX = cursor.readFloat64(true);
+  const maxY = cursor.readFloat64(true);
+  const gaiaMbr = cursor.readUint8();
+  if (gaiaMbr !== GAIA_MBR) {
+    throw new GaiaFormatError(
+      `Invalid GAIA MBR marker: expected 0x${GAIA_MBR.toString(16)}, got 0x${gaiaMbr.toString(16)}.`
+    );
+  }
+  const geoType = cursor.readInt32(true);
+  if (expectedGeoType !== void 0 && geoType !== expectedGeoType) {
+    throw new GaiaGeoTypeMismatchError(expectedGeoType, geoType);
+  }
+  return {
+    byteOrder,
+    srid,
+    mbr: [minX, minY, maxX, maxY],
+    geoType,
+    geometryDataOffset: GAIA_GEOMETRY_DATA_OFFSET
+  };
+}
+function validateGaiaEnd(cursor) {
+  const gaiaEnd = cursor.readUint8();
+  if (gaiaEnd !== GAIA_END) {
+    throw new GaiaFormatError(
+      `Invalid GAIA end marker: expected 0x${GAIA_END.toString(16)}, got 0x${gaiaEnd.toString(16)}.`
+    );
+  }
+}
+
+// src/core/geometry/gaia/GaiaPointCodec.ts
+function isPoint3D(geometry) {
+  return geometry.coordinates.length === 3;
+}
+function createPointMbr(coordinates) {
+  return [coordinates[0], coordinates[1], coordinates[0], coordinates[1]];
+}
+function writeGaiaHeader(writer, srid, mbr, geoType) {
+  writer.writeUint8(GAIA_START);
+  writer.writeUint8(GAIA_BYTE_ORDER_LE);
+  writer.writeInt32(srid, true);
+  writer.writeFloat64(mbr[0], true);
+  writer.writeFloat64(mbr[1], true);
+  writer.writeFloat64(mbr[2], true);
+  writer.writeFloat64(mbr[3], true);
+  writer.writeUint8(GAIA_MBR);
+  writer.writeInt32(geoType, true);
+}
+var GaiaPointCodec = class {
+  static readPoint(input) {
+    const cursor = new BinaryCursor(input);
+    const header = readGaiaHeader(cursor, GEO_TYPE_POINT);
+    const x = cursor.readFloat64(true);
+    const y = cursor.readFloat64(true);
+    validateGaiaEnd(cursor);
+    return {
+      type: "Point",
+      coordinates: [x, y],
+      srid: header.srid,
+      bbox: header.mbr,
+      hasZ: false,
+      geoType: header.geoType
+    };
+  }
+  static readPointZ(input) {
+    const cursor = new BinaryCursor(input);
+    const header = readGaiaHeader(cursor, GEO_TYPE_POINTZ);
+    const x = cursor.readFloat64(true);
+    const y = cursor.readFloat64(true);
+    const z = cursor.readFloat64(true);
+    validateGaiaEnd(cursor);
+    return {
+      type: "Point",
+      coordinates: [x, y, z],
+      srid: header.srid,
+      bbox: header.mbr,
+      hasZ: true,
+      geoType: header.geoType
+    };
+  }
+  static writePoint(geometry, srid) {
+    if (isPoint3D(geometry)) {
+      throw new GaiaFormatError("writePoint expects a 2D Point geometry.");
+    }
+    const writer = new BinaryWriter(60);
+    const mbr = createPointMbr(geometry.coordinates);
+    writeGaiaHeader(writer, srid, mbr, GEO_TYPE_POINT);
+    writer.writeFloat64(geometry.coordinates[0], true);
+    writer.writeFloat64(geometry.coordinates[1], true);
+    writer.writeUint8(GAIA_END);
+    return writer.toUint8Array();
+  }
+  static writePointZ(geometry, srid) {
+    if (!isPoint3D(geometry)) {
+      throw new GaiaFormatError("writePointZ expects a 3D Point geometry.");
+    }
+    const writer = new BinaryWriter(68);
+    const mbr = createPointMbr(geometry.coordinates);
+    writeGaiaHeader(writer, srid, mbr, GEO_TYPE_POINTZ);
+    writer.writeFloat64(geometry.coordinates[0], true);
+    writer.writeFloat64(geometry.coordinates[1], true);
+    writer.writeFloat64(geometry.coordinates[2], true);
+    writer.writeUint8(GAIA_END);
+    return writer.toUint8Array();
+  }
+};
+
+// src/core/geometry/gaia/GaiaLineCodec.ts
+var GAIA_ENTITY_MARK = 105;
+var GEO_TYPE_LINESTRING = 2;
+var GEO_TYPE_LINESTRINGZ = 1002;
+function is3DCoordinates(coordinates) {
+  return coordinates[0]?.[0]?.length === 3;
+}
+function createLineMbr(coordinates) {
+  const xs = [];
+  const ys = [];
+  for (const line of coordinates) {
+    for (const point of line) {
+      xs.push(point[0]);
+      ys.push(point[1]);
+    }
+  }
+  if (xs.length === 0) {
+    throw new GaiaFormatError("MultiLineString must contain at least one point.");
+  }
+  return [
+    Math.min(...xs),
+    Math.min(...ys),
+    Math.max(...xs),
+    Math.max(...ys)
+  ];
+}
+var GaiaLineCodec = class {
+  static readMultiLineString(input) {
+    const cursor = new BinaryCursor(input);
+    const header = readGaiaHeader(cursor, GEO_TYPE_MULTILINESTRING);
+    const lineCount = cursor.readInt32(true);
+    const coordinates = [];
+    for (let lineIndex = 0; lineIndex < lineCount; lineIndex += 1) {
+      const entityMark = cursor.readUint8();
+      if (entityMark !== GAIA_ENTITY_MARK) {
+        throw new GaiaFormatError(
+          `Invalid LineString entity mark: expected 0x${GAIA_ENTITY_MARK.toString(16)}, got 0x${entityMark.toString(16)}.`
+        );
+      }
+      const lineGeoType = cursor.readInt32(true);
+      if (lineGeoType !== GEO_TYPE_LINESTRING) {
+        throw new GaiaFormatError(
+          `Invalid LineString geoType: expected ${GEO_TYPE_LINESTRING}, got ${lineGeoType}.`
+        );
+      }
+      const pointCount = cursor.readInt32(true);
+      const line = [];
+      for (let pointIndex = 0; pointIndex < pointCount; pointIndex += 1) {
+        line.push([cursor.readFloat64(true), cursor.readFloat64(true)]);
+      }
+      coordinates.push(line);
+    }
+    validateGaiaEnd(cursor);
+    return {
+      type: "MultiLineString",
+      coordinates,
+      srid: header.srid,
+      bbox: header.mbr,
+      hasZ: false,
+      geoType: header.geoType
+    };
+  }
+  static readMultiLineStringZ(input) {
+    const cursor = new BinaryCursor(input);
+    const header = readGaiaHeader(cursor, GEO_TYPE_MULTILINESTRINGZ);
+    const lineCount = cursor.readInt32(true);
+    const coordinates = [];
+    for (let lineIndex = 0; lineIndex < lineCount; lineIndex += 1) {
+      const entityMark = cursor.readUint8();
+      if (entityMark !== GAIA_ENTITY_MARK) {
+        throw new GaiaFormatError(
+          `Invalid LineString entity mark: expected 0x${GAIA_ENTITY_MARK.toString(16)}, got 0x${entityMark.toString(16)}.`
+        );
+      }
+      const lineGeoType = cursor.readInt32(true);
+      if (lineGeoType !== GEO_TYPE_LINESTRINGZ) {
+        throw new GaiaFormatError(
+          `Invalid LineStringZ geoType: expected ${GEO_TYPE_LINESTRINGZ}, got ${lineGeoType}.`
+        );
+      }
+      const pointCount = cursor.readInt32(true);
+      const line = [];
+      for (let pointIndex = 0; pointIndex < pointCount; pointIndex += 1) {
+        line.push([
+          cursor.readFloat64(true),
+          cursor.readFloat64(true),
+          cursor.readFloat64(true)
+        ]);
+      }
+      coordinates.push(line);
+    }
+    validateGaiaEnd(cursor);
+    return {
+      type: "MultiLineString",
+      coordinates,
+      srid: header.srid,
+      bbox: header.mbr,
+      hasZ: true,
+      geoType: header.geoType
+    };
+  }
+  static writeMultiLineString(geometry, srid) {
+    if (is3DCoordinates(geometry.coordinates)) {
+      throw new GaiaFormatError(
+        "writeMultiLineString expects 2D coordinates."
+      );
+    }
+    const writer = new BinaryWriter();
+    writeGaiaHeader(
+      writer,
+      srid,
+      createLineMbr(geometry.coordinates),
+      GEO_TYPE_MULTILINESTRING
+    );
+    writer.writeInt32(geometry.coordinates.length, true);
+    for (const line of geometry.coordinates) {
+      writer.writeUint8(GAIA_ENTITY_MARK);
+      writer.writeInt32(GEO_TYPE_LINESTRING, true);
+      writer.writeInt32(line.length, true);
+      for (const point of line) {
+        writer.writeFloat64(point[0], true);
+        writer.writeFloat64(point[1], true);
+      }
+    }
+    writer.writeUint8(GAIA_END);
+    return writer.toUint8Array();
+  }
+  static writeMultiLineStringZ(geometry, srid) {
+    if (!is3DCoordinates(geometry.coordinates)) {
+      throw new GaiaFormatError(
+        "writeMultiLineStringZ expects 3D coordinates."
+      );
+    }
+    const writer = new BinaryWriter();
+    writeGaiaHeader(
+      writer,
+      srid,
+      createLineMbr(geometry.coordinates),
+      GEO_TYPE_MULTILINESTRINGZ
+    );
+    writer.writeInt32(geometry.coordinates.length, true);
+    for (const line of geometry.coordinates) {
+      writer.writeUint8(GAIA_ENTITY_MARK);
+      writer.writeInt32(GEO_TYPE_LINESTRINGZ, true);
+      writer.writeInt32(line.length, true);
+      for (const point of line) {
+        writer.writeFloat64(point[0], true);
+        writer.writeFloat64(point[1], true);
+        writer.writeFloat64(point[2], true);
+      }
+    }
+    writer.writeUint8(GAIA_END);
+    return writer.toUint8Array();
+  }
+};
+
+// src/core/schema/SmRegisterRepository.ts
+function mapRow2(row) {
+  return {
+    id: row.SmDatasetID,
+    name: row.SmDatasetName,
+    kind: datasetValueToKind(row.SmDatasetType),
+    tableName: row.SmTableName,
+    srid: row.SmSRID ?? null,
+    objectCount: row.SmObjectCount,
+    geometryType: row.geometryType ?? null
+  };
+}
+var SmRegisterRepository = class {
+  constructor(driver) {
+    this.driver = driver;
+  }
+  async findAll() {
+    const rows = await queryAll(
+      this.driver,
+      `SELECT
+         SmDatasetID,
+         SmDatasetName,
+         SmTableName,
+         SmDatasetType,
+         SmObjectCount,
+         SmSRID
+       FROM SmRegister
+       ORDER BY SmDatasetID`
+    );
+    return rows.map(mapRow2);
+  }
+  async findByName(name) {
+    const row = await queryOne(
+      this.driver,
+      `SELECT
+         SmDatasetID,
+         SmDatasetName,
+         SmTableName,
+         SmDatasetType,
+         SmObjectCount,
+         SmSRID
+       FROM SmRegister
+       WHERE SmDatasetName = ?`,
+      [name]
+    );
+    return row ? mapRow2(row) : null;
+  }
+  async nextDatasetId() {
+    const row = await queryOne(
+      this.driver,
+      "SELECT COALESCE(MAX(SmDatasetID), 0) + 1 AS nextId FROM SmRegister"
+    );
+    return row?.nextId ?? 1;
+  }
+  async insert(params) {
+    const datasetId = await this.nextDatasetId();
+    const statement = await this.driver.prepare(
+      `INSERT INTO SmRegister (
+         SmDatasetID,
+         SmDatasetName,
+         SmTableName,
+         SmDatasetType,
+         SmObjectCount,
+         SmSRID,
+         SmIDColName,
+         SmGeoColName,
+         SmMaxGeometrySize,
+         SmCreateTime,
+         SmLastUpdateTime
+       ) VALUES (?, ?, ?, ?, 0, ?, ?, ?, 0, datetime('now'), datetime('now'))`
+    );
+    await executeStatement(statement, [
+      datasetId,
+      params.name,
+      params.name,
+      datasetKindToValue(params.kind),
+      params.srid,
+      params.idColumnName,
+      params.geometryColumnName
+    ]);
+    return datasetId;
+  }
+  async incrementObjectCount(datasetId, geometrySize) {
+    if (geometrySize === void 0) {
+      const statement2 = await this.driver.prepare(
+        "UPDATE SmRegister SET SmObjectCount = SmObjectCount + 1 WHERE SmDatasetID = ?"
+      );
+      await executeStatement(statement2, [datasetId]);
+      return;
+    }
+    const statement = await this.driver.prepare(
+      `UPDATE SmRegister
+       SET SmObjectCount = SmObjectCount + 1,
+           SmMaxGeometrySize = CASE
+             WHEN SmMaxGeometrySize < ? THEN ?
+             ELSE SmMaxGeometrySize
+           END
+       WHERE SmDatasetID = ?`
+    );
+    await executeStatement(statement, [geometrySize, geometrySize, datasetId]);
+  }
+  async incrementObjectCountBatch(datasetId, count, maxGeometrySize) {
+    const statement = await this.driver.prepare(
+      `UPDATE SmRegister
+       SET SmObjectCount = SmObjectCount + ?,
+           SmMaxGeometrySize = CASE
+             WHEN SmMaxGeometrySize < ? THEN ?
+             ELSE SmMaxGeometrySize
+           END
+       WHERE SmDatasetID = ?`
+    );
+    await executeStatement(statement, [
+      count,
+      maxGeometrySize,
+      maxGeometrySize,
+      datasetId
+    ]);
+  }
+  async decrementObjectCount(datasetId) {
+    const statement = await this.driver.prepare(
+      "UPDATE SmRegister SET SmObjectCount = SmObjectCount - 1 WHERE SmDatasetID = ? AND SmObjectCount > 0"
+    );
+    await executeStatement(statement, [datasetId]);
+  }
+};
+
+// src/core/dataset/vectorDatasetShared.ts
+function normalizeGeometryBlob(value) {
+  return value instanceof Uint8Array ? value : new Uint8Array(value);
+}
+function buildListSql(tableName, options) {
+  const params = [];
+  const clauses = [];
+  if (options?.ids?.length) {
+    const placeholders = options.ids.map(() => "?").join(", ");
+    clauses.push(`SmID IN (${placeholders})`);
+    params.push(...options.ids);
+  }
+  const whereClause = clauses.length > 0 ? ` WHERE ${clauses.join(" AND ")}` : "";
+  let sql = `SELECT * FROM "${tableName}"${whereClause} ORDER BY SmID`;
+  if (options?.limit !== void 0) {
+    sql += " LIMIT ?";
+    params.push(options.limit);
+  }
+  if (options?.offset !== void 0) {
+    if (options.limit === void 0) {
+      sql += " LIMIT -1";
+    }
+    sql += " OFFSET ?";
+    params.push(options.offset);
+  }
+  return { sql, params };
+}
+function sqliteColumnType(field) {
+  switch (field.fieldType) {
+    case "boolean":
+    case "byte":
+    case "int16":
+    case "int32":
+    case "int64":
+      return "INTEGER";
+    case "single":
+    case "double":
+      return "REAL";
+    case "binary":
+    case "geometry":
+      return "BLOB";
+    case "date":
+    case "char":
+    case "ntext":
+    case "text":
+    case "time":
+    default:
+      return "TEXT";
+  }
+}
+
+// src/core/dataset/LineDataset.ts
+function mapLineRow(row) {
+  const { SmID, SmGeometry, ...attributes } = row;
+  return {
+    id: SmID,
+    geometry: GaiaLineCodec.readMultiLineString(normalizeGeometryBlob(SmGeometry)),
+    attributes
+  };
+}
+var LineDataset = class _LineDataset extends BaseDataset {
+  constructor(driver, info) {
+    super(driver, info);
+    __publicField(this, "registerRepository");
+    this.registerRepository = new SmRegisterRepository(driver);
+  }
+  async getById(id) {
+    const row = await queryOne(
+      this.driver,
+      `SELECT * FROM "${this.info.tableName}" WHERE SmID = ?`,
+      [id]
+    );
+    return row ? mapLineRow(row) : null;
+  }
+  async list(options) {
+    const { sql, params } = buildListSql(this.info.tableName, options);
+    const rows = await queryAll(this.driver, sql, params);
+    return rows.map((row) => mapLineRow(row));
+  }
+  async *iterate(options) {
+    const { sql, params } = buildListSql(this.info.tableName, options);
+    const statement = await this.driver.prepare(sql);
+    try {
+      if (params.length > 0) {
+        await statement.bind(params);
+      }
+      while (await statement.step()) {
+        yield mapLineRow(await statement.getRow());
+      }
+    } finally {
+      await statement.finalize();
+    }
+  }
+  async insert(feature) {
+    const userFields = await this.getFields();
+    const columnNames = ["SmID", "SmUserID", "SmGeometry", ...userFields.map((field) => field.name)];
+    const placeholders = columnNames.map(() => "?").join(", ");
+    const geometry = GaiaLineCodec.writeMultiLineString(
+      feature.geometry,
+      feature.geometry.srid ?? this.info.srid ?? 0
+    );
+    const sql = `INSERT INTO "${this.info.tableName}" (${columnNames.map((column) => `"${column}"`).join(", ")}) VALUES (${placeholders})`;
+    const params = [
+      feature.id,
+      0,
+      geometry,
+      ...userFields.map((field) => feature.attributes[field.name] ?? null)
+    ];
+    await this.driver.transaction(async () => {
+      await executeSql(this.driver, sql, params);
+      await this.registerRepository.incrementObjectCount(this.info.id, geometry.byteLength);
+    });
+  }
+  async insertMany(features) {
+    const userFields = await this.getFields();
+    const columnNames = ["SmID", "SmUserID", "SmGeometry", ...userFields.map((field) => field.name)];
+    const placeholders = columnNames.map(() => "?").join(", ");
+    const sql = `INSERT INTO "${this.info.tableName}" (${columnNames.map((column) => `"${column}"`).join(", ")}) VALUES (${placeholders})`;
+    await this.driver.transaction(async () => {
+      const statement = await this.driver.prepare(sql);
+      try {
+        let count = 0;
+        let maxGeometrySize = 0;
+        for await (const feature of features) {
+          const geometry = GaiaLineCodec.writeMultiLineString(
+            feature.geometry,
+            feature.geometry.srid ?? this.info.srid ?? 0
+          );
+          maxGeometrySize = Math.max(maxGeometrySize, geometry.byteLength);
+          const params = [
+            feature.id,
+            0,
+            geometry,
+            ...userFields.map(
+              (field) => feature.attributes[field.name] ?? null
+            )
+          ];
+          await statement.bind(params);
+          await statement.step();
+          await statement.reset();
+          count++;
+        }
+        if (count > 0) {
+          await this.registerRepository.incrementObjectCountBatch(
+            this.info.id,
+            count,
+            maxGeometrySize
+          );
+        }
+      } finally {
+        await statement.finalize();
+      }
+    });
+  }
+  async count() {
+    const row = await queryOne(
+      this.driver,
+      `SELECT COUNT(*) AS count FROM "${this.info.tableName}"`,
+      []
+    );
+    return row?.count ?? 0;
+  }
+  async update(id, changes) {
+    if (!changes.geometry && !changes.attributes) {
+      return;
+    }
+    const setClauses = [];
+    const params = [];
+    if (changes.geometry) {
+      const geometry = GaiaLineCodec.writeMultiLineString(
+        changes.geometry,
+        changes.geometry.srid ?? this.info.srid ?? 0
+      );
+      setClauses.push('"SmGeometry" = ?');
+      params.push(geometry);
+    }
+    if (changes.attributes) {
+      const userFields = await this.getFields();
+      const fieldNames = new Set(userFields.map((f) => f.name));
+      const validEntries = Object.entries(changes.attributes).filter(
+        ([key]) => fieldNames.has(key)
+      );
+      for (const [key, value] of validEntries) {
+        setClauses.push(`"${key}" = ?`);
+        params.push(value);
+      }
+    }
+    if (setClauses.length === 0) {
+      return;
+    }
+    const sql = `UPDATE "${this.info.tableName}" SET ${setClauses.join(", ")} WHERE SmID = ?`;
+    params.push(id);
+    await this.driver.transaction(async () => {
+      await executeSql(this.driver, sql, params);
+    });
+  }
+  async delete(id) {
+    await this.driver.transaction(async () => {
+      await executeSql(
+        this.driver,
+        `DELETE FROM "${this.info.tableName}" WHERE SmID = ?`,
+        [id]
+      );
+      await this.registerRepository.decrementObjectCount(this.info.id);
+    });
+  }
+  static async create(driver, registerRepository, params) {
+    const fields = params.fields ?? [];
+    const datasetId = await registerRepository.insert({
+      name: params.name,
+      kind: "line",
+      srid: params.srid,
+      idColumnName: "SmID",
+      geometryColumnName: "SmGeometry"
+    });
+    const userColumnDefinitions = fields.map((field) => {
+      const nullability = field.nullable ? "" : " NOT NULL";
+      return `"${field.name}" ${sqliteColumnType(field)}${nullability}`;
+    });
+    const createTableParts = [
+      `"SmID" INTEGER NOT NULL PRIMARY KEY`,
+      `"SmUserID" INTEGER DEFAULT 0 NOT NULL`,
+      `"SmGeometry" BLOB NOT NULL`,
+      ...userColumnDefinitions
+    ];
+    await driver.exec(
+      `CREATE TABLE "${params.name}" (${createTableParts.join(", ")})`
+    );
+    await executeSql(
+      driver,
+      `INSERT INTO geometry_columns (
+         f_table_name,
+         f_geometry_column,
+         geometry_type,
+         coord_dimension,
+         srid,
+         spatial_index_enabled
+       ) VALUES (?, ?, ?, ?, ?, ?)`,
+      [params.name, "SmGeometry", 5, 2, params.srid, 0]
+    );
+    if (fields.length > 0) {
+      const fieldInfoRepository = new SmFieldInfoRepository(driver);
+      await fieldInfoRepository.insertAll(datasetId, fields);
+    }
+    return new _LineDataset(driver, {
+      id: datasetId,
+      name: params.name,
+      kind: "line",
+      tableName: params.name,
+      srid: params.srid,
+      objectCount: 0,
+      geometryType: 5
+    });
+  }
+};
+
+// src/core/dataset/LineZDataset.ts
+function mapLineZRow(row) {
+  const { SmID, SmGeometry, ...attributes } = row;
+  return {
+    id: SmID,
+    geometry: GaiaLineCodec.readMultiLineStringZ(normalizeGeometryBlob(SmGeometry)),
+    attributes
+  };
+}
+var LineZDataset = class _LineZDataset extends BaseDataset {
+  constructor(driver, info) {
+    super(driver, info);
+    __publicField(this, "registerRepository");
+    this.registerRepository = new SmRegisterRepository(driver);
+  }
+  async getById(id) {
+    const row = await queryOne(
+      this.driver,
+      `SELECT * FROM "${this.info.tableName}" WHERE SmID = ?`,
+      [id]
+    );
+    return row ? mapLineZRow(row) : null;
+  }
+  async list(options) {
+    const { sql, params } = buildListSql(this.info.tableName, options);
+    const rows = await queryAll(this.driver, sql, params);
+    return rows.map((row) => mapLineZRow(row));
+  }
+  async *iterate(options) {
+    const { sql, params } = buildListSql(this.info.tableName, options);
+    const statement = await this.driver.prepare(sql);
+    try {
+      if (params.length > 0) {
+        await statement.bind(params);
+      }
+      while (await statement.step()) {
+        yield mapLineZRow(await statement.getRow());
+      }
+    } finally {
+      await statement.finalize();
+    }
+  }
+  async count() {
+    const row = await queryOne(
+      this.driver,
+      `SELECT COUNT(*) AS count FROM "${this.info.tableName}"`,
+      []
+    );
+    return row?.count ?? 0;
+  }
+  async insert(feature) {
+    const userFields = await this.getFields();
+    const columnNames = ["SmID", "SmUserID", "SmGeometry", ...userFields.map((field) => field.name)];
+    const placeholders = columnNames.map(() => "?").join(", ");
+    const geometry = GaiaLineCodec.writeMultiLineStringZ(
+      feature.geometry,
+      feature.geometry.srid ?? this.info.srid ?? 0
+    );
+    const sql = `INSERT INTO "${this.info.tableName}" (${columnNames.map((column) => `"${column}"`).join(", ")}) VALUES (${placeholders})`;
+    const params = [
+      feature.id,
+      0,
+      geometry,
+      ...userFields.map((field) => feature.attributes[field.name] ?? null)
+    ];
+    await this.driver.transaction(async () => {
+      await executeSql(this.driver, sql, params);
+      await this.registerRepository.incrementObjectCount(this.info.id, geometry.byteLength);
+    });
+  }
+  async insertMany(features) {
+    const userFields = await this.getFields();
+    const columnNames = ["SmID", "SmUserID", "SmGeometry", ...userFields.map((field) => field.name)];
+    const placeholders = columnNames.map(() => "?").join(", ");
+    const sql = `INSERT INTO "${this.info.tableName}" (${columnNames.map((column) => `"${column}"`).join(", ")}) VALUES (${placeholders})`;
+    await this.driver.transaction(async () => {
+      const statement = await this.driver.prepare(sql);
+      try {
+        let count = 0;
+        let maxGeometrySize = 0;
+        for await (const feature of features) {
+          const geometry = GaiaLineCodec.writeMultiLineStringZ(
+            feature.geometry,
+            feature.geometry.srid ?? this.info.srid ?? 0
+          );
+          maxGeometrySize = Math.max(maxGeometrySize, geometry.byteLength);
+          const params = [
+            feature.id,
+            0,
+            geometry,
+            ...userFields.map(
+              (field) => feature.attributes[field.name] ?? null
+            )
+          ];
+          await statement.bind(params);
+          await statement.step();
+          await statement.reset();
+          count++;
+        }
+        if (count > 0) {
+          await this.registerRepository.incrementObjectCountBatch(
+            this.info.id,
+            count,
+            maxGeometrySize
+          );
+        }
+      } finally {
+        await statement.finalize();
+      }
+    });
+  }
+  async update(id, changes) {
+    if (!changes.geometry && !changes.attributes) {
+      return;
+    }
+    const setClauses = [];
+    const params = [];
+    if (changes.geometry) {
+      const geometry = GaiaLineCodec.writeMultiLineStringZ(
+        changes.geometry,
+        changes.geometry.srid ?? this.info.srid ?? 0
+      );
+      setClauses.push('"SmGeometry" = ?');
+      params.push(geometry);
+    }
+    if (changes.attributes) {
+      const userFields = await this.getFields();
+      const fieldNames = new Set(userFields.map((f) => f.name));
+      const validEntries = Object.entries(changes.attributes).filter(
+        ([key]) => fieldNames.has(key)
+      );
+      for (const [key, value] of validEntries) {
+        setClauses.push(`"${key}" = ?`);
+        params.push(value);
+      }
+    }
+    if (setClauses.length === 0) {
+      return;
+    }
+    const sql = `UPDATE "${this.info.tableName}" SET ${setClauses.join(", ")} WHERE SmID = ?`;
+    params.push(id);
+    await this.driver.transaction(async () => {
+      await executeSql(this.driver, sql, params);
+    });
+  }
+  async delete(id) {
+    await this.driver.transaction(async () => {
+      await executeSql(
+        this.driver,
+        `DELETE FROM "${this.info.tableName}" WHERE SmID = ?`,
+        [id]
+      );
+      await this.registerRepository.decrementObjectCount(this.info.id);
+    });
+  }
+  static async create(driver, registerRepository, params) {
+    const fields = params.fields ?? [];
+    const datasetId = await registerRepository.insert({
+      name: params.name,
+      kind: "lineZ",
+      srid: params.srid,
+      idColumnName: "SmID",
+      geometryColumnName: "SmGeometry"
+    });
+    const userColumnDefinitions = fields.map((field) => {
+      const nullability = field.nullable ? "" : " NOT NULL";
+      return `"${field.name}" ${sqliteColumnType(field)}${nullability}`;
+    });
+    const createTableParts = [
+      `"SmID" INTEGER NOT NULL PRIMARY KEY`,
+      `"SmUserID" INTEGER DEFAULT 0 NOT NULL`,
+      `"SmGeometry" BLOB NOT NULL`,
+      ...userColumnDefinitions
+    ];
+    await driver.exec(
+      `CREATE TABLE "${params.name}" (${createTableParts.join(", ")})`
+    );
+    await executeSql(
+      driver,
+      `INSERT INTO geometry_columns (
+         f_table_name,
+         f_geometry_column,
+         geometry_type,
+         coord_dimension,
+         srid,
+         spatial_index_enabled
+       ) VALUES (?, ?, ?, ?, ?, ?)`,
+      [params.name, "SmGeometry", 1005, 3, params.srid, 0]
+    );
+    if (fields.length > 0) {
+      const fieldInfoRepository = new SmFieldInfoRepository(driver);
+      await fieldInfoRepository.insertAll(datasetId, fields);
+    }
+    return new _LineZDataset(driver, {
+      id: datasetId,
+      name: params.name,
+      kind: "lineZ",
+      tableName: params.name,
+      srid: params.srid,
+      objectCount: 0,
+      geometryType: 1005
+    });
+  }
+};
+
+// src/core/dataset/PointDataset.ts
+function mapPointRow(row) {
+  const { SmID, SmGeometry, ...attributes } = row;
+  return {
+    id: SmID,
+    geometry: GaiaPointCodec.readPoint(normalizeGeometryBlob(SmGeometry)),
+    attributes
+  };
+}
+var PointDataset = class _PointDataset extends BaseDataset {
+  constructor(driver, info) {
+    super(driver, info);
+    __publicField(this, "registerRepository");
+    this.registerRepository = new SmRegisterRepository(driver);
+  }
+  async getById(id) {
+    const row = await queryOne(
+      this.driver,
+      `SELECT * FROM "${this.info.tableName}" WHERE SmID = ?`,
+      [id]
+    );
+    return row ? mapPointRow(row) : null;
+  }
+  async list(options) {
+    const { sql, params } = buildListSql(this.info.tableName, options);
+    const rows = await queryAll(this.driver, sql, params);
+    return rows.map((row) => mapPointRow(row));
+  }
+  async *iterate(options) {
+    const { sql, params } = buildListSql(this.info.tableName, options);
+    const statement = await this.driver.prepare(sql);
+    try {
+      if (params.length > 0) {
+        await statement.bind(params);
+      }
+      while (await statement.step()) {
+        yield mapPointRow(await statement.getRow());
+      }
+    } finally {
+      await statement.finalize();
+    }
+  }
+  async insert(feature) {
+    const userFields = await this.getFields();
+    const columnNames = ["SmID", "SmUserID", "SmGeometry", ...userFields.map((field) => field.name)];
+    const placeholders = columnNames.map(() => "?").join(", ");
+    const geometry = GaiaPointCodec.writePoint(feature.geometry, feature.geometry.srid ?? this.info.srid ?? 0);
+    const sql = `INSERT INTO "${this.info.tableName}" (${columnNames.map((column) => `"${column}"`).join(", ")}) VALUES (${placeholders})`;
+    const params = [
+      feature.id,
+      0,
+      geometry,
+      ...userFields.map((field) => feature.attributes[field.name] ?? null)
+    ];
+    await this.driver.transaction(async () => {
+      await executeSql(this.driver, sql, params);
+      await this.registerRepository.incrementObjectCount(this.info.id, geometry.byteLength);
+    });
+  }
+  async insertMany(features) {
+    const userFields = await this.getFields();
+    const columnNames = ["SmID", "SmUserID", "SmGeometry", ...userFields.map((field) => field.name)];
+    const placeholders = columnNames.map(() => "?").join(", ");
+    const sql = `INSERT INTO "${this.info.tableName}" (${columnNames.map((column) => `"${column}"`).join(", ")}) VALUES (${placeholders})`;
+    await this.driver.transaction(async () => {
+      const statement = await this.driver.prepare(sql);
+      try {
+        let count = 0;
+        let maxGeometrySize = 0;
+        for await (const feature of features) {
+          const geometry = GaiaPointCodec.writePoint(
+            feature.geometry,
+            feature.geometry.srid ?? this.info.srid ?? 0
+          );
+          maxGeometrySize = Math.max(maxGeometrySize, geometry.byteLength);
+          const params = [
+            feature.id,
+            0,
+            geometry,
+            ...userFields.map(
+              (field) => feature.attributes[field.name] ?? null
+            )
+          ];
+          await statement.bind(params);
+          await statement.step();
+          await statement.reset();
+          count++;
+        }
+        if (count > 0) {
+          await this.registerRepository.incrementObjectCountBatch(
+            this.info.id,
+            count,
+            maxGeometrySize
+          );
+        }
+      } finally {
+        await statement.finalize();
+      }
+    });
+  }
+  async count() {
+    const row = await queryOne(
+      this.driver,
+      `SELECT COUNT(*) AS count FROM "${this.info.tableName}"`,
+      []
+    );
+    return row?.count ?? 0;
+  }
+  async update(id, changes) {
+    if (!changes.geometry && !changes.attributes) {
+      return;
+    }
+    const setClauses = [];
+    const params = [];
+    if (changes.geometry) {
+      const geometry = GaiaPointCodec.writePoint(
+        changes.geometry,
+        changes.geometry.srid ?? this.info.srid ?? 0
+      );
+      setClauses.push('"SmGeometry" = ?');
+      params.push(geometry);
+    }
+    if (changes.attributes) {
+      const userFields = await this.getFields();
+      const fieldNames = new Set(userFields.map((f) => f.name));
+      const validEntries = Object.entries(changes.attributes).filter(
+        ([key]) => fieldNames.has(key)
+      );
+      for (const [key, value] of validEntries) {
+        setClauses.push(`"${key}" = ?`);
+        params.push(value);
+      }
+    }
+    if (setClauses.length === 0) {
+      return;
+    }
+    const sql = `UPDATE "${this.info.tableName}" SET ${setClauses.join(", ")} WHERE SmID = ?`;
+    params.push(id);
+    await this.driver.transaction(async () => {
+      await executeSql(this.driver, sql, params);
+    });
+  }
+  async delete(id) {
+    await this.driver.transaction(async () => {
+      await executeSql(
+        this.driver,
+        `DELETE FROM "${this.info.tableName}" WHERE SmID = ?`,
+        [id]
+      );
+      await this.registerRepository.decrementObjectCount(this.info.id);
+    });
+  }
+  static async create(driver, registerRepository, params) {
+    const fields = params.fields ?? [];
+    const datasetId = await registerRepository.insert({
+      name: params.name,
+      kind: "point",
+      srid: params.srid,
+      idColumnName: "SmID",
+      geometryColumnName: "SmGeometry"
+    });
+    const userColumnDefinitions = fields.map((field) => {
+      const nullability = field.nullable ? "" : " NOT NULL";
+      return `"${field.name}" ${sqliteColumnType(field)}${nullability}`;
+    });
+    const createTableParts = [
+      `"SmID" INTEGER NOT NULL PRIMARY KEY`,
+      `"SmUserID" INTEGER DEFAULT 0 NOT NULL`,
+      `"SmGeometry" BLOB NOT NULL`,
+      ...userColumnDefinitions
+    ];
+    await driver.exec(
+      `CREATE TABLE "${params.name}" (${createTableParts.join(", ")})`
+    );
+    await executeSql(
+      driver,
+      `INSERT INTO geometry_columns (
+         f_table_name,
+         f_geometry_column,
+         geometry_type,
+         coord_dimension,
+         srid,
+         spatial_index_enabled
+       ) VALUES (?, ?, ?, ?, ?, ?)`,
+      [params.name, "SmGeometry", 1, 2, params.srid, 0]
+    );
+    if (fields.length > 0) {
+      const fieldInfoRepository = new SmFieldInfoRepository(driver);
+      await fieldInfoRepository.insertAll(datasetId, fields);
+    }
+    return new _PointDataset(driver, {
+      id: datasetId,
+      name: params.name,
+      kind: "point",
+      tableName: params.name,
+      srid: params.srid,
+      objectCount: 0,
+      geometryType: 1
+    });
+  }
+};
+
+// src/core/dataset/PointZDataset.ts
+function mapPointZRow(row) {
+  const { SmID, SmGeometry, ...attributes } = row;
+  return {
+    id: SmID,
+    geometry: GaiaPointCodec.readPointZ(normalizeGeometryBlob(SmGeometry)),
+    attributes
+  };
+}
+var PointZDataset = class _PointZDataset extends BaseDataset {
+  constructor(driver, info) {
+    super(driver, info);
+    __publicField(this, "registerRepository");
+    this.registerRepository = new SmRegisterRepository(driver);
+  }
+  async getById(id) {
+    const row = await queryOne(
+      this.driver,
+      `SELECT * FROM "${this.info.tableName}" WHERE SmID = ?`,
+      [id]
+    );
+    return row ? mapPointZRow(row) : null;
+  }
+  async list(options) {
+    const { sql, params } = buildListSql(this.info.tableName, options);
+    const rows = await queryAll(this.driver, sql, params);
+    return rows.map((row) => mapPointZRow(row));
+  }
+  async *iterate(options) {
+    const { sql, params } = buildListSql(this.info.tableName, options);
+    const statement = await this.driver.prepare(sql);
+    try {
+      if (params.length > 0) {
+        await statement.bind(params);
+      }
+      while (await statement.step()) {
+        yield mapPointZRow(await statement.getRow());
+      }
+    } finally {
+      await statement.finalize();
+    }
+  }
+  async count() {
+    const row = await queryOne(
+      this.driver,
+      `SELECT COUNT(*) AS count FROM "${this.info.tableName}"`,
+      []
+    );
+    return row?.count ?? 0;
+  }
+  async insert(feature) {
+    const userFields = await this.getFields();
+    const columnNames = ["SmID", "SmUserID", "SmGeometry", ...userFields.map((field) => field.name)];
+    const placeholders = columnNames.map(() => "?").join(", ");
+    const geometry = GaiaPointCodec.writePointZ(
+      feature.geometry,
+      feature.geometry.srid ?? this.info.srid ?? 0
+    );
+    const sql = `INSERT INTO "${this.info.tableName}" (${columnNames.map((column) => `"${column}"`).join(", ")}) VALUES (${placeholders})`;
+    const params = [
+      feature.id,
+      0,
+      geometry,
+      ...userFields.map((field) => feature.attributes[field.name] ?? null)
+    ];
+    await this.driver.transaction(async () => {
+      await executeSql(this.driver, sql, params);
+      await this.registerRepository.incrementObjectCount(this.info.id, geometry.byteLength);
+    });
+  }
+  async insertMany(features) {
+    const userFields = await this.getFields();
+    const columnNames = ["SmID", "SmUserID", "SmGeometry", ...userFields.map((field) => field.name)];
+    const placeholders = columnNames.map(() => "?").join(", ");
+    const sql = `INSERT INTO "${this.info.tableName}" (${columnNames.map((column) => `"${column}"`).join(", ")}) VALUES (${placeholders})`;
+    await this.driver.transaction(async () => {
+      const statement = await this.driver.prepare(sql);
+      try {
+        let count = 0;
+        let maxGeometrySize = 0;
+        for await (const feature of features) {
+          const geometry = GaiaPointCodec.writePointZ(
+            feature.geometry,
+            feature.geometry.srid ?? this.info.srid ?? 0
+          );
+          maxGeometrySize = Math.max(maxGeometrySize, geometry.byteLength);
+          const params = [
+            feature.id,
+            0,
+            geometry,
+            ...userFields.map(
+              (field) => feature.attributes[field.name] ?? null
+            )
+          ];
+          await statement.bind(params);
+          await statement.step();
+          await statement.reset();
+          count++;
+        }
+        if (count > 0) {
+          await this.registerRepository.incrementObjectCountBatch(
+            this.info.id,
+            count,
+            maxGeometrySize
+          );
+        }
+      } finally {
+        await statement.finalize();
+      }
+    });
+  }
+  async update(id, changes) {
+    if (!changes.geometry && !changes.attributes) {
+      return;
+    }
+    const setClauses = [];
+    const params = [];
+    if (changes.geometry) {
+      const geometry = GaiaPointCodec.writePointZ(
+        changes.geometry,
+        changes.geometry.srid ?? this.info.srid ?? 0
+      );
+      setClauses.push('"SmGeometry" = ?');
+      params.push(geometry);
+    }
+    if (changes.attributes) {
+      const userFields = await this.getFields();
+      const fieldNames = new Set(userFields.map((f) => f.name));
+      const validEntries = Object.entries(changes.attributes).filter(
+        ([key]) => fieldNames.has(key)
+      );
+      for (const [key, value] of validEntries) {
+        setClauses.push(`"${key}" = ?`);
+        params.push(value);
+      }
+    }
+    if (setClauses.length === 0) {
+      return;
+    }
+    const sql = `UPDATE "${this.info.tableName}" SET ${setClauses.join(", ")} WHERE SmID = ?`;
+    params.push(id);
+    await this.driver.transaction(async () => {
+      await executeSql(this.driver, sql, params);
+    });
+  }
+  async delete(id) {
+    await this.driver.transaction(async () => {
+      await executeSql(
+        this.driver,
+        `DELETE FROM "${this.info.tableName}" WHERE SmID = ?`,
+        [id]
+      );
+      await this.registerRepository.decrementObjectCount(this.info.id);
+    });
+  }
+  static async create(driver, registerRepository, params) {
+    const fields = params.fields ?? [];
+    const datasetId = await registerRepository.insert({
+      name: params.name,
+      kind: "pointZ",
+      srid: params.srid,
+      idColumnName: "SmID",
+      geometryColumnName: "SmGeometry"
+    });
+    const userColumnDefinitions = fields.map((field) => {
+      const nullability = field.nullable ? "" : " NOT NULL";
+      return `"${field.name}" ${sqliteColumnType(field)}${nullability}`;
+    });
+    const createTableParts = [
+      `"SmID" INTEGER NOT NULL PRIMARY KEY`,
+      `"SmUserID" INTEGER DEFAULT 0 NOT NULL`,
+      `"SmGeometry" BLOB NOT NULL`,
+      ...userColumnDefinitions
+    ];
+    await driver.exec(
+      `CREATE TABLE "${params.name}" (${createTableParts.join(", ")})`
+    );
+    await executeSql(
+      driver,
+      `INSERT INTO geometry_columns (
+         f_table_name,
+         f_geometry_column,
+         geometry_type,
+         coord_dimension,
+         srid,
+         spatial_index_enabled
+       ) VALUES (?, ?, ?, ?, ?, ?)`,
+      [params.name, "SmGeometry", 1001, 3, params.srid, 0]
+    );
+    if (fields.length > 0) {
+      const fieldInfoRepository = new SmFieldInfoRepository(driver);
+      await fieldInfoRepository.insertAll(datasetId, fields);
+    }
+    return new _PointZDataset(driver, {
+      id: datasetId,
+      name: params.name,
+      kind: "pointZ",
+      tableName: params.name,
+      srid: params.srid,
+      objectCount: 0,
+      geometryType: 1001
+    });
+  }
+};
+
+// src/core/geometry/gaia/GaiaPolygonCodec.ts
+var GAIA_ENTITY_MARK2 = 105;
+var GEO_TYPE_POLYGON = 3;
+var GEO_TYPE_POLYGONZ = 1003;
+function is3DCoordinates2(coordinates) {
+  return coordinates[0]?.[0]?.[0]?.length === 3;
+}
+function createPolygonMbr(coordinates) {
+  const xs = [];
+  const ys = [];
+  for (const polygon of coordinates) {
+    for (const ring of polygon) {
+      for (const point of ring) {
+        xs.push(point[0]);
+        ys.push(point[1]);
+      }
+    }
+  }
+  if (xs.length === 0) {
+    throw new GaiaFormatError("MultiPolygon must contain at least one point.");
+  }
+  return [
+    Math.min(...xs),
+    Math.min(...ys),
+    Math.max(...xs),
+    Math.max(...ys)
+  ];
+}
+function writeRing2D(writer, ring) {
+  writer.writeInt32(ring.length, true);
+  for (const point of ring) {
+    writer.writeFloat64(point[0], true);
+    writer.writeFloat64(point[1], true);
+  }
+}
+function writeRing3D(writer, ring) {
+  writer.writeInt32(ring.length, true);
+  for (const point of ring) {
+    writer.writeFloat64(point[0], true);
+    writer.writeFloat64(point[1], true);
+    writer.writeFloat64(point[2], true);
+  }
+}
+function readRing2D(cursor) {
+  const pointCount = cursor.readInt32(true);
+  const ring = [];
+  for (let pointIndex = 0; pointIndex < pointCount; pointIndex += 1) {
+    ring.push([cursor.readFloat64(true), cursor.readFloat64(true)]);
+  }
+  return ring;
+}
+function readRing3D(cursor) {
+  const pointCount = cursor.readInt32(true);
+  const ring = [];
+  for (let pointIndex = 0; pointIndex < pointCount; pointIndex += 1) {
+    ring.push([
+      cursor.readFloat64(true),
+      cursor.readFloat64(true),
+      cursor.readFloat64(true)
+    ]);
+  }
+  return ring;
+}
+var GaiaPolygonCodec = class {
+  static readMultiPolygon(input) {
+    const cursor = new BinaryCursor(input);
+    const header = readGaiaHeader(cursor, GEO_TYPE_MULTIPOLYGON);
+    const polygonCount = cursor.readInt32(true);
+    const coordinates = [];
+    for (let polygonIndex = 0; polygonIndex < polygonCount; polygonIndex += 1) {
+      const entityMark = cursor.readUint8();
+      if (entityMark !== GAIA_ENTITY_MARK2) {
+        throw new GaiaFormatError(
+          `Invalid Polygon entity mark: expected 0x${GAIA_ENTITY_MARK2.toString(16)}, got 0x${entityMark.toString(16)}.`
+        );
+      }
+      const polygonGeoType = cursor.readInt32(true);
+      if (polygonGeoType !== GEO_TYPE_POLYGON) {
+        throw new GaiaFormatError(
+          `Invalid Polygon geoType: expected ${GEO_TYPE_POLYGON}, got ${polygonGeoType}.`
+        );
+      }
+      const ringCount = cursor.readInt32(true);
+      if (ringCount < 1) {
+        throw new GaiaFormatError(
+          `Polygon must contain at least one ring, got ${ringCount}.`
+        );
+      }
+      const polygon = [];
+      for (let ringIndex = 0; ringIndex < ringCount; ringIndex += 1) {
+        polygon.push(readRing2D(cursor));
+      }
+      coordinates.push(polygon);
+    }
+    validateGaiaEnd(cursor);
+    return {
+      type: "MultiPolygon",
+      coordinates,
+      srid: header.srid,
+      bbox: header.mbr,
+      hasZ: false,
+      geoType: header.geoType
+    };
+  }
+  static readMultiPolygonZ(input) {
+    const cursor = new BinaryCursor(input);
+    const header = readGaiaHeader(cursor, GEO_TYPE_MULTIPOLYGONZ);
+    const polygonCount = cursor.readInt32(true);
+    const coordinates = [];
+    for (let polygonIndex = 0; polygonIndex < polygonCount; polygonIndex += 1) {
+      const entityMark = cursor.readUint8();
+      if (entityMark !== GAIA_ENTITY_MARK2) {
+        throw new GaiaFormatError(
+          `Invalid Polygon entity mark: expected 0x${GAIA_ENTITY_MARK2.toString(16)}, got 0x${entityMark.toString(16)}.`
+        );
+      }
+      const polygonGeoType = cursor.readInt32(true);
+      if (polygonGeoType !== GEO_TYPE_POLYGONZ) {
+        throw new GaiaFormatError(
+          `Invalid PolygonZ geoType: expected ${GEO_TYPE_POLYGONZ}, got ${polygonGeoType}.`
+        );
+      }
+      const ringCount = cursor.readInt32(true);
+      if (ringCount < 1) {
+        throw new GaiaFormatError(
+          `Polygon must contain at least one ring, got ${ringCount}.`
+        );
+      }
+      const polygon = [];
+      for (let ringIndex = 0; ringIndex < ringCount; ringIndex += 1) {
+        polygon.push(readRing3D(cursor));
+      }
+      coordinates.push(polygon);
+    }
+    validateGaiaEnd(cursor);
+    return {
+      type: "MultiPolygon",
+      coordinates,
+      srid: header.srid,
+      bbox: header.mbr,
+      hasZ: true,
+      geoType: header.geoType
+    };
+  }
+  static writeMultiPolygon(geometry, srid) {
+    if (is3DCoordinates2(geometry.coordinates)) {
+      throw new GaiaFormatError("writeMultiPolygon expects 2D coordinates.");
+    }
+    const writer = new BinaryWriter();
+    writeGaiaHeader(
+      writer,
+      srid,
+      createPolygonMbr(geometry.coordinates),
+      GEO_TYPE_MULTIPOLYGON
+    );
+    writer.writeInt32(geometry.coordinates.length, true);
+    for (const polygon of geometry.coordinates) {
+      writer.writeUint8(GAIA_ENTITY_MARK2);
+      writer.writeInt32(GEO_TYPE_POLYGON, true);
+      writer.writeInt32(polygon.length, true);
+      for (const ring of polygon) {
+        writeRing2D(writer, ring);
+      }
+    }
+    writer.writeUint8(GAIA_END);
+    return writer.toUint8Array();
+  }
+  static writeMultiPolygonZ(geometry, srid) {
+    if (!is3DCoordinates2(geometry.coordinates)) {
+      throw new GaiaFormatError("writeMultiPolygonZ expects 3D coordinates.");
+    }
+    const writer = new BinaryWriter();
+    writeGaiaHeader(
+      writer,
+      srid,
+      createPolygonMbr(geometry.coordinates),
+      GEO_TYPE_MULTIPOLYGONZ
+    );
+    writer.writeInt32(geometry.coordinates.length, true);
+    for (const polygon of geometry.coordinates) {
+      writer.writeUint8(GAIA_ENTITY_MARK2);
+      writer.writeInt32(GEO_TYPE_POLYGONZ, true);
+      writer.writeInt32(polygon.length, true);
+      for (const ring of polygon) {
+        writeRing3D(writer, ring);
+      }
+    }
+    writer.writeUint8(GAIA_END);
+    return writer.toUint8Array();
+  }
+};
+
+// src/core/dataset/RegionDataset.ts
+function mapRegionRow(row) {
+  const { SmID, SmGeometry, ...attributes } = row;
+  return {
+    id: SmID,
+    geometry: GaiaPolygonCodec.readMultiPolygon(normalizeGeometryBlob(SmGeometry)),
+    attributes
+  };
+}
+var RegionDataset = class _RegionDataset extends BaseDataset {
+  constructor(driver, info) {
+    super(driver, info);
+    __publicField(this, "registerRepository");
+    this.registerRepository = new SmRegisterRepository(driver);
+  }
+  async getById(id) {
+    const row = await queryOne(
+      this.driver,
+      `SELECT * FROM "${this.info.tableName}" WHERE SmID = ?`,
+      [id]
+    );
+    return row ? mapRegionRow(row) : null;
+  }
+  async list(options) {
+    const { sql, params } = buildListSql(this.info.tableName, options);
+    const rows = await queryAll(this.driver, sql, params);
+    return rows.map((row) => mapRegionRow(row));
+  }
+  async *iterate(options) {
+    const { sql, params } = buildListSql(this.info.tableName, options);
+    const statement = await this.driver.prepare(sql);
+    try {
+      if (params.length > 0) {
+        await statement.bind(params);
+      }
+      while (await statement.step()) {
+        yield mapRegionRow(
+          await statement.getRow()
+        );
+      }
+    } finally {
+      await statement.finalize();
+    }
+  }
+  async insert(feature) {
+    const userFields = await this.getFields();
+    const columnNames = ["SmID", "SmUserID", "SmGeometry", ...userFields.map((field) => field.name)];
+    const placeholders = columnNames.map(() => "?").join(", ");
+    const geometry = GaiaPolygonCodec.writeMultiPolygon(
+      feature.geometry,
+      feature.geometry.srid ?? this.info.srid ?? 0
+    );
+    const sql = `INSERT INTO "${this.info.tableName}" (${columnNames.map((column) => `"${column}"`).join(", ")}) VALUES (${placeholders})`;
+    const params = [
+      feature.id,
+      0,
+      geometry,
+      ...userFields.map((field) => feature.attributes[field.name] ?? null)
+    ];
+    await this.driver.transaction(async () => {
+      await executeSql(this.driver, sql, params);
+      await this.registerRepository.incrementObjectCount(this.info.id, geometry.byteLength);
+    });
+  }
+  async insertMany(features) {
+    const userFields = await this.getFields();
+    const columnNames = ["SmID", "SmUserID", "SmGeometry", ...userFields.map((field) => field.name)];
+    const placeholders = columnNames.map(() => "?").join(", ");
+    const sql = `INSERT INTO "${this.info.tableName}" (${columnNames.map((column) => `"${column}"`).join(", ")}) VALUES (${placeholders})`;
+    await this.driver.transaction(async () => {
+      const statement = await this.driver.prepare(sql);
+      try {
+        let count = 0;
+        let maxGeometrySize = 0;
+        for await (const feature of features) {
+          const geometry = GaiaPolygonCodec.writeMultiPolygon(
+            feature.geometry,
+            feature.geometry.srid ?? this.info.srid ?? 0
+          );
+          maxGeometrySize = Math.max(maxGeometrySize, geometry.byteLength);
+          const params = [
+            feature.id,
+            0,
+            geometry,
+            ...userFields.map(
+              (field) => feature.attributes[field.name] ?? null
+            )
+          ];
+          await statement.bind(params);
+          await statement.step();
+          await statement.reset();
+          count++;
+        }
+        if (count > 0) {
+          await this.registerRepository.incrementObjectCountBatch(
+            this.info.id,
+            count,
+            maxGeometrySize
+          );
+        }
+      } finally {
+        await statement.finalize();
+      }
+    });
+  }
+  async count() {
+    const row = await queryOne(
+      this.driver,
+      `SELECT COUNT(*) AS count FROM "${this.info.tableName}"`,
+      []
+    );
+    return row?.count ?? 0;
+  }
+  async update(id, changes) {
+    if (!changes.geometry && !changes.attributes) {
+      return;
+    }
+    const setClauses = [];
+    const params = [];
+    if (changes.geometry) {
+      const geometry = GaiaPolygonCodec.writeMultiPolygon(
+        changes.geometry,
+        changes.geometry.srid ?? this.info.srid ?? 0
+      );
+      setClauses.push('"SmGeometry" = ?');
+      params.push(geometry);
+    }
+    if (changes.attributes) {
+      const userFields = await this.getFields();
+      const fieldNames = new Set(userFields.map((f) => f.name));
+      const validEntries = Object.entries(changes.attributes).filter(
+        ([key]) => fieldNames.has(key)
+      );
+      for (const [key, value] of validEntries) {
+        setClauses.push(`"${key}" = ?`);
+        params.push(value);
+      }
+    }
+    if (setClauses.length === 0) {
+      return;
+    }
+    const sql = `UPDATE "${this.info.tableName}" SET ${setClauses.join(", ")} WHERE SmID = ?`;
+    params.push(id);
+    await this.driver.transaction(async () => {
+      await executeSql(this.driver, sql, params);
+    });
+  }
+  async delete(id) {
+    await this.driver.transaction(async () => {
+      await executeSql(
+        this.driver,
+        `DELETE FROM "${this.info.tableName}" WHERE SmID = ?`,
+        [id]
+      );
+      await this.registerRepository.decrementObjectCount(this.info.id);
+    });
+  }
+  static async create(driver, registerRepository, params) {
+    const fields = params.fields ?? [];
+    const datasetId = await registerRepository.insert({
+      name: params.name,
+      kind: "region",
+      srid: params.srid,
+      idColumnName: "SmID",
+      geometryColumnName: "SmGeometry"
+    });
+    const userColumnDefinitions = fields.map((field) => {
+      const nullability = field.nullable ? "" : " NOT NULL";
+      return `"${field.name}" ${sqliteColumnType(field)}${nullability}`;
+    });
+    const createTableParts = [
+      `"SmID" INTEGER NOT NULL PRIMARY KEY`,
+      `"SmUserID" INTEGER DEFAULT 0 NOT NULL`,
+      `"SmGeometry" BLOB NOT NULL`,
+      ...userColumnDefinitions
+    ];
+    await driver.exec(
+      `CREATE TABLE "${params.name}" (${createTableParts.join(", ")})`
+    );
+    await executeSql(
+      driver,
+      `INSERT INTO geometry_columns (
+         f_table_name,
+         f_geometry_column,
+         geometry_type,
+         coord_dimension,
+         srid,
+         spatial_index_enabled
+       ) VALUES (?, ?, ?, ?, ?, ?)`,
+      [params.name, "SmGeometry", 6, 2, params.srid, 0]
+    );
+    if (fields.length > 0) {
+      const fieldInfoRepository = new SmFieldInfoRepository(driver);
+      await fieldInfoRepository.insertAll(datasetId, fields);
+    }
+    return new _RegionDataset(driver, {
+      id: datasetId,
+      name: params.name,
+      kind: "region",
+      tableName: params.name,
+      srid: params.srid,
+      objectCount: 0,
+      geometryType: 6
+    });
+  }
+};
+
+// src/core/dataset/RegionZDataset.ts
+function mapRegionZRow(row) {
+  const { SmID, SmGeometry, ...attributes } = row;
+  return {
+    id: SmID,
+    geometry: GaiaPolygonCodec.readMultiPolygonZ(normalizeGeometryBlob(SmGeometry)),
+    attributes
+  };
+}
+var RegionZDataset = class _RegionZDataset extends BaseDataset {
+  constructor(driver, info) {
+    super(driver, info);
+    __publicField(this, "registerRepository");
+    this.registerRepository = new SmRegisterRepository(driver);
+  }
+  async getById(id) {
+    const row = await queryOne(
+      this.driver,
+      `SELECT * FROM "${this.info.tableName}" WHERE SmID = ?`,
+      [id]
+    );
+    return row ? mapRegionZRow(row) : null;
+  }
+  async list(options) {
+    const { sql, params } = buildListSql(this.info.tableName, options);
+    const rows = await queryAll(this.driver, sql, params);
+    return rows.map((row) => mapRegionZRow(row));
+  }
+  async *iterate(options) {
+    const { sql, params } = buildListSql(this.info.tableName, options);
+    const statement = await this.driver.prepare(sql);
+    try {
+      if (params.length > 0) {
+        await statement.bind(params);
+      }
+      while (await statement.step()) {
+        yield mapRegionZRow(
+          await statement.getRow()
+        );
+      }
+    } finally {
+      await statement.finalize();
+    }
+  }
+  async count() {
+    const row = await queryOne(
+      this.driver,
+      `SELECT COUNT(*) AS count FROM "${this.info.tableName}"`,
+      []
+    );
+    return row?.count ?? 0;
+  }
+  async insert(feature) {
+    const userFields = await this.getFields();
+    const columnNames = ["SmID", "SmUserID", "SmGeometry", ...userFields.map((field) => field.name)];
+    const placeholders = columnNames.map(() => "?").join(", ");
+    const geometry = GaiaPolygonCodec.writeMultiPolygonZ(
+      feature.geometry,
+      feature.geometry.srid ?? this.info.srid ?? 0
+    );
+    const sql = `INSERT INTO "${this.info.tableName}" (${columnNames.map((column) => `"${column}"`).join(", ")}) VALUES (${placeholders})`;
+    const params = [
+      feature.id,
+      0,
+      geometry,
+      ...userFields.map((field) => feature.attributes[field.name] ?? null)
+    ];
+    await this.driver.transaction(async () => {
+      await executeSql(this.driver, sql, params);
+      await this.registerRepository.incrementObjectCount(this.info.id, geometry.byteLength);
+    });
+  }
+  async insertMany(features) {
+    const userFields = await this.getFields();
+    const columnNames = ["SmID", "SmUserID", "SmGeometry", ...userFields.map((field) => field.name)];
+    const placeholders = columnNames.map(() => "?").join(", ");
+    const sql = `INSERT INTO "${this.info.tableName}" (${columnNames.map((column) => `"${column}"`).join(", ")}) VALUES (${placeholders})`;
+    await this.driver.transaction(async () => {
+      const statement = await this.driver.prepare(sql);
+      try {
+        let count = 0;
+        let maxGeometrySize = 0;
+        for await (const feature of features) {
+          const geometry = GaiaPolygonCodec.writeMultiPolygonZ(
+            feature.geometry,
+            feature.geometry.srid ?? this.info.srid ?? 0
+          );
+          maxGeometrySize = Math.max(maxGeometrySize, geometry.byteLength);
+          const params = [
+            feature.id,
+            0,
+            geometry,
+            ...userFields.map(
+              (field) => feature.attributes[field.name] ?? null
+            )
+          ];
+          await statement.bind(params);
+          await statement.step();
+          await statement.reset();
+          count++;
+        }
+        if (count > 0) {
+          await this.registerRepository.incrementObjectCountBatch(
+            this.info.id,
+            count,
+            maxGeometrySize
+          );
+        }
+      } finally {
+        await statement.finalize();
+      }
+    });
+  }
+  async update(id, changes) {
+    if (!changes.geometry && !changes.attributes) {
+      return;
+    }
+    const setClauses = [];
+    const params = [];
+    if (changes.geometry) {
+      const geometry = GaiaPolygonCodec.writeMultiPolygonZ(
+        changes.geometry,
+        changes.geometry.srid ?? this.info.srid ?? 0
+      );
+      setClauses.push('"SmGeometry" = ?');
+      params.push(geometry);
+    }
+    if (changes.attributes) {
+      const userFields = await this.getFields();
+      const fieldNames = new Set(userFields.map((f) => f.name));
+      const validEntries = Object.entries(changes.attributes).filter(
+        ([key]) => fieldNames.has(key)
+      );
+      for (const [key, value] of validEntries) {
+        setClauses.push(`"${key}" = ?`);
+        params.push(value);
+      }
+    }
+    if (setClauses.length === 0) {
+      return;
+    }
+    const sql = `UPDATE "${this.info.tableName}" SET ${setClauses.join(", ")} WHERE SmID = ?`;
+    params.push(id);
+    await this.driver.transaction(async () => {
+      await executeSql(this.driver, sql, params);
+    });
+  }
+  async delete(id) {
+    await this.driver.transaction(async () => {
+      await executeSql(
+        this.driver,
+        `DELETE FROM "${this.info.tableName}" WHERE SmID = ?`,
+        [id]
+      );
+      await this.registerRepository.decrementObjectCount(this.info.id);
+    });
+  }
+  static async create(driver, registerRepository, params) {
+    const fields = params.fields ?? [];
+    const datasetId = await registerRepository.insert({
+      name: params.name,
+      kind: "regionZ",
+      srid: params.srid,
+      idColumnName: "SmID",
+      geometryColumnName: "SmGeometry"
+    });
+    const userColumnDefinitions = fields.map((field) => {
+      const nullability = field.nullable ? "" : " NOT NULL";
+      return `"${field.name}" ${sqliteColumnType(field)}${nullability}`;
+    });
+    const createTableParts = [
+      `"SmID" INTEGER NOT NULL PRIMARY KEY`,
+      `"SmUserID" INTEGER DEFAULT 0 NOT NULL`,
+      `"SmGeometry" BLOB NOT NULL`,
+      ...userColumnDefinitions
+    ];
+    await driver.exec(
+      `CREATE TABLE "${params.name}" (${createTableParts.join(", ")})`
+    );
+    await executeSql(
+      driver,
+      `INSERT INTO geometry_columns (
+         f_table_name,
+         f_geometry_column,
+         geometry_type,
+         coord_dimension,
+         srid,
+         spatial_index_enabled
+       ) VALUES (?, ?, ?, ?, ?, ?)`,
+      [params.name, "SmGeometry", 1006, 3, params.srid, 0]
+    );
+    if (fields.length > 0) {
+      const fieldInfoRepository = new SmFieldInfoRepository(driver);
+      await fieldInfoRepository.insertAll(datasetId, fields);
+    }
+    return new _RegionZDataset(driver, {
+      id: datasetId,
+      name: params.name,
+      kind: "regionZ",
+      tableName: params.name,
+      srid: params.srid,
+      objectCount: 0,
+      geometryType: 1006
+    });
+  }
+};
+
+// src/core/dataset/TabularDataset.ts
+var SYSTEM_COLUMN_PREFIX = "Sm";
+function mapTabularRow(row) {
+  const { SmID, ...rest } = row;
+  const attributes = {};
+  for (const [key, value] of Object.entries(rest)) {
+    if (!key.startsWith(SYSTEM_COLUMN_PREFIX)) {
+      attributes[key] = value;
+    }
+  }
+  return {
+    id: SmID,
+    attributes
+  };
+}
+var TabularDataset = class _TabularDataset extends BaseDataset {
+  constructor(driver, info) {
+    super(driver, info);
+    __publicField(this, "registerRepository");
+    this.registerRepository = new SmRegisterRepository(driver);
+  }
+  async getById(id) {
+    const row = await queryOne(
+      this.driver,
+      `SELECT * FROM "${this.info.tableName}" WHERE SmID = ?`,
+      [id]
+    );
+    return row ? mapTabularRow(row) : null;
+  }
+  async list(options) {
+    const { sql, params } = buildListSql(this.info.tableName, options);
+    const rows = await queryAll(this.driver, sql, params);
+    return rows.map((row) => mapTabularRow(row));
+  }
+  async *iterate(options) {
+    const { sql, params } = buildListSql(this.info.tableName, options);
+    const statement = await this.driver.prepare(sql);
+    try {
+      if (params.length > 0) {
+        await statement.bind(params);
+      }
+      while (await statement.step()) {
+        yield mapTabularRow(
+          await statement.getRow()
+        );
+      }
+    } finally {
+      await statement.finalize();
+    }
+  }
+  async count() {
+    const row = await queryOne(
+      this.driver,
+      `SELECT COUNT(*) AS count FROM "${this.info.tableName}"`,
+      []
+    );
+    return row?.count ?? 0;
+  }
+  async insert(record) {
+    const userFields = await this.getFields();
+    const columnNames = [
+      "SmID",
+      "SmUserID",
+      ...userFields.map((field) => field.name)
+    ];
+    const placeholders = columnNames.map(() => "?").join(", ");
+    const sql = `INSERT INTO "${this.info.tableName}" (${columnNames.map((column) => `"${column}"`).join(", ")}) VALUES (${placeholders})`;
+    const params = [
+      record.id,
+      0,
+      ...userFields.map(
+        (field) => record.attributes[field.name] ?? null
+      )
+    ];
+    await this.driver.transaction(async () => {
+      await executeSql(this.driver, sql, params);
+      await this.registerRepository.incrementObjectCount(this.info.id);
+    });
+  }
+  async insertMany(records) {
+    const userFields = await this.getFields();
+    const columnNames = [
+      "SmID",
+      "SmUserID",
+      ...userFields.map((field) => field.name)
+    ];
+    const placeholders = columnNames.map(() => "?").join(", ");
+    const sql = `INSERT INTO "${this.info.tableName}" (${columnNames.map((column) => `"${column}"`).join(", ")}) VALUES (${placeholders})`;
+    await this.driver.transaction(async () => {
+      const statement = await this.driver.prepare(sql);
+      try {
+        let count = 0;
+        for await (const record of records) {
+          const params = [
+            record.id,
+            0,
+            ...userFields.map(
+              (field) => record.attributes[field.name] ?? null
+            )
+          ];
+          await statement.bind(params);
+          await statement.step();
+          await statement.reset();
+          count++;
+        }
+        if (count > 0) {
+          await this.registerRepository.incrementObjectCountBatch(
+            this.info.id,
+            count,
+            0
+          );
+        }
+      } finally {
+        await statement.finalize();
+      }
+    });
+  }
+  async update(id, attributes) {
+    const userFields = await this.getFields();
+    const fieldNames = new Set(userFields.map((f) => f.name));
+    const validEntries = Object.entries(attributes).filter(
+      ([key]) => fieldNames.has(key)
+    );
+    if (validEntries.length === 0) return;
+    const keys = validEntries.map(([key]) => key);
+    const setClauses = keys.map((key) => `"${key}" = ?`).join(", ");
+    const sql = `UPDATE "${this.info.tableName}" SET ${setClauses} WHERE SmID = ?`;
+    const params = [
+      ...keys.map((key) => attributes[key]),
+      id
+    ];
+    await this.driver.transaction(async () => {
+      await executeSql(this.driver, sql, params);
+    });
+  }
+  async delete(id) {
+    await this.driver.transaction(async () => {
+      await executeSql(
+        this.driver,
+        `DELETE FROM "${this.info.tableName}" WHERE SmID = ?`,
+        [id]
+      );
+      await this.registerRepository.decrementObjectCount(this.info.id);
+    });
+  }
+  static async create(driver, registerRepository, params) {
+    const fields = params.fields ?? [];
+    const datasetId = await registerRepository.insert({
+      name: params.name,
+      kind: "tabular",
+      srid: 0,
+      idColumnName: "SmID",
+      geometryColumnName: null
+    });
+    const userColumnDefinitions = fields.map((field) => {
+      const nullability = field.nullable ? "" : " NOT NULL";
+      return `"${field.name}" ${sqliteColumnType(field)}${nullability}`;
+    });
+    const createTableParts = [
+      `"SmID" INTEGER NOT NULL PRIMARY KEY`,
+      `"SmUserID" INTEGER DEFAULT 0 NOT NULL`,
+      ...userColumnDefinitions
+    ];
+    await driver.exec(
+      `CREATE TABLE "${params.name}" (${createTableParts.join(", ")})`
+    );
+    if (fields.length > 0) {
+      const fieldInfoRepository = new SmFieldInfoRepository(driver);
+      await fieldInfoRepository.insertAll(datasetId, fields);
+    }
+    return new _TabularDataset(driver, {
+      id: datasetId,
+      name: params.name,
+      kind: "tabular",
+      tableName: params.name,
+      srid: 0,
+      objectCount: 0,
+      geometryType: null
+    });
+  }
+};
+
+// src/core/dataset/TextDataset.ts
+var TextDataset = class extends BaseDataset {
+  async getById() {
+    throw createNotImplementedError("TextDataset.getById");
+  }
+  async list(_options) {
+    throw createNotImplementedError("TextDataset.list");
+  }
+  async *iterate(_options) {
+    throw createNotImplementedError("TextDataset.iterate");
+  }
+  async count() {
+    throw createNotImplementedError("TextDataset.count");
+  }
+  async insert() {
+    throw createNotImplementedError("TextDataset.insert");
+  }
+  async insertMany() {
+    throw createNotImplementedError("TextDataset.insertMany");
+  }
+  async update() {
+    throw createNotImplementedError("TextDataset.update");
+  }
+  async delete() {
+    throw createNotImplementedError("TextDataset.delete");
+  }
+};
+
+// src/core/schema/UdbxSchemaInitializer.ts
+var UDBX_SCHEMA_STATEMENTS = [
+  `CREATE TABLE spatial_ref_sys (
+    srid INTEGER NOT NULL PRIMARY KEY,
+    auth_name TEXT NOT NULL,
+    auth_srid INTEGER NOT NULL,
+    ref_sys_name TEXT NOT NULL DEFAULT 'Unknown',
+    proj4text TEXT NOT NULL,
+    srtext TEXT NOT NULL DEFAULT 'Undefined'
+  )`,
+  `CREATE TABLE geometry_columns (
+    f_table_name TEXT NOT NULL,
+    f_geometry_column TEXT NOT NULL,
+    geometry_type INTEGER NOT NULL,
+    coord_dimension INTEGER NOT NULL,
+    srid INTEGER NOT NULL,
+    spatial_index_enabled INTEGER NOT NULL,
+    CONSTRAINT pk_geom_cols PRIMARY KEY (f_table_name, f_geometry_column)
+  )`,
+  `CREATE TABLE SmDataSourceInfo (
+    SmFlag INTEGER DEFAULT 0 NOT NULL PRIMARY KEY AUTOINCREMENT,
+    SmVersion INTEGER,
+    SmDsDescription TEXT,
+    SmProjectInfo BLOB,
+    SmLastUpdateTime DATE DEFAULT CURRENT_TIMESTAMP NOT NULL,
+    SmDataFormat INTEGER DEFAULT 0 NOT NULL
+  )`,
+  `CREATE TABLE SmRegister (
+    SmDatasetID INTEGER DEFAULT 0 NOT NULL PRIMARY KEY,
+    SmDatasetName TEXT,
+    SmTableName TEXT,
+    SmOption INTEGER,
+    SmEncType INTEGER,
+    SmParentDTID INTEGER DEFAULT 0 NOT NULL,
+    SmDatasetType INTEGER,
+    SmObjectCount INTEGER DEFAULT 0 NOT NULL,
+    SmLeft REAL,
+    SmRight REAL,
+    SmTop REAL,
+    SmBottom REAL,
+    SmIDColName TEXT,
+    SmGeoColName TEXT,
+    SmMinZ REAL,
+    SmMaxZ REAL,
+    SmSRID INTEGER DEFAULT 0,
+    SmIndexType INTEGER DEFAULT 1,
+    SmToleRanceFuzzy REAL,
+    SmToleranceDAngle REAL,
+    SmToleranceNodeSnap REAL,
+    SmToleranceSmallPolygon REAL,
+    SmToleranceGrain REAL,
+    SmMaxGeometrySize INTEGER DEFAULT 0 NOT NULL,
+    SmOptimizeCount INTEGER DEFAULT 0 NOT NULL,
+    SmOptimizeRatio REAL,
+    SmDescription TEXT,
+    SmExtInfo TEXT,
+    SmCreateTime TEXT,
+    SmLastUpdateTime TEXT,
+    SmProjectInfo BLOB
+  )`,
+  `CREATE TABLE SmFieldInfo (
+    SmID INTEGER DEFAULT 0 NOT NULL PRIMARY KEY AUTOINCREMENT,
+    SmDatasetID INTEGER,
+    SmFieldName TEXT,
+    SmFieldCaption TEXT,
+    SmFieldType INTEGER,
+    SmFieldFormat TEXT,
+    SmFieldSign INTEGER,
+    SmFieldDomain TEXT,
+    SmFieldUpdatable INTEGER,
+    SmFieldbRequired INTEGER,
+    SmFieldDefaultValue TEXT,
+    SmFieldSize INTEGER
+  )`,
+  "INSERT INTO SmDataSourceInfo (SmVersion, SmDataFormat) VALUES (0, 1)",
+  "INSERT INTO spatial_ref_sys (srid, auth_name, auth_srid, ref_sys_name, proj4text, srtext) VALUES (0, 'none', 0, 'Undefined', '', 'Undefined')",
+  `INSERT INTO spatial_ref_sys (srid, auth_name, auth_srid, ref_sys_name, proj4text, srtext)
+   VALUES (
+    4326,
+    'epsg',
+    4326,
+    'WGS 84',
+    '+proj=longlat +datum=WGS84 +no_defs',
+    'GEOGCS["WGS 84",DATUM["WGS_1984",SPHEROID["WGS 84",6378137,298.257223563]],PRIMEM["Greenwich",0],UNIT["degree",0.0174532925199433],AUTHORITY["EPSG","4326"]]'
+   )`
+];
+var UdbxSchemaInitializer = class {
+  static async isInitialized(driver) {
+    const statement = await driver.prepare(
+      "SELECT name FROM sqlite_master WHERE type = 'table' AND name = ? LIMIT 1"
+    );
+    try {
+      await statement.bind(["SmDataSourceInfo"]);
+      return statement.step();
+    } finally {
+      await statement.finalize();
+    }
+  }
+  static async ensureInitialized(driver) {
+    const initialized = await this.isInitialized(driver);
+    if (initialized) {
+      return false;
+    }
+    await this.initialize(driver);
+    return true;
+  }
+  static async initialize(driver) {
+    await driver.exec("PRAGMA journal_mode = WAL");
+    await driver.transaction(async () => {
+      for (const statement of UDBX_SCHEMA_STATEMENTS) {
+        await driver.exec(statement);
+      }
+    });
+  }
+};
+
+// src/core/datasource/UdbxDataSource.ts
+var UdbxDataSource = class _UdbxDataSource {
+  constructor(driver, runtime = "unknown") {
+    this.driver = driver;
+    this.runtime = runtime;
+    __publicField(this, "registerRepository");
+    this.registerRepository = new SmRegisterRepository(driver);
+  }
+  static async open(params) {
+    await params.driver.open(params.target);
+    return new _UdbxDataSource(params.driver, params.runtime ?? "unknown");
+  }
+  static async create(params) {
+    await params.driver.open(params.target);
+    await UdbxSchemaInitializer.initialize(params.driver);
+    return new _UdbxDataSource(params.driver, params.runtime ?? "unknown");
+  }
+  async listDatasets() {
+    return this.registerRepository.findAll();
+  }
+  async getDataset(name) {
+    const info = await this.registerRepository.findByName(name);
+    if (!info) {
+      return null;
+    }
+    switch (info.kind) {
+      case "point":
+        return new PointDataset(this.driver, info);
+      case "pointZ":
+        return new PointZDataset(this.driver, info);
+      case "line":
+        return new LineDataset(this.driver, info);
+      case "lineZ":
+        return new LineZDataset(this.driver, info);
+      case "region":
+        return new RegionDataset(this.driver, info);
+      case "regionZ":
+        return new RegionZDataset(this.driver, info);
+      case "tabular":
+        return new TabularDataset(this.driver, info);
+      case "text":
+        return new TextDataset(this.driver, info);
+      case "cad":
+        return new CadDataset(this.driver, info);
+      default:
+        return null;
+    }
+  }
+  async createPointDataset(name, srid, fields) {
+    return this.driver.transaction(async () => {
+      const params = fields === void 0 ? { name, srid } : { name, srid, fields };
+      return PointDataset.create(this.driver, this.registerRepository, params);
+    });
+  }
+  async createLineDataset(name, srid, fields) {
+    return this.driver.transaction(async () => {
+      const params = fields === void 0 ? { name, srid } : { name, srid, fields };
+      return LineDataset.create(this.driver, this.registerRepository, params);
+    });
+  }
+  async createRegionDataset(name, srid, fields) {
+    return this.driver.transaction(async () => {
+      const params = fields === void 0 ? { name, srid } : { name, srid, fields };
+      return RegionDataset.create(this.driver, this.registerRepository, params);
+    });
+  }
+  async createPointZDataset(name, srid, fields) {
+    return this.driver.transaction(async () => {
+      const params = fields === void 0 ? { name, srid } : { name, srid, fields };
+      return PointZDataset.create(this.driver, this.registerRepository, params);
+    });
+  }
+  async createLineZDataset(name, srid, fields) {
+    return this.driver.transaction(async () => {
+      const params = fields === void 0 ? { name, srid } : { name, srid, fields };
+      return LineZDataset.create(this.driver, this.registerRepository, params);
+    });
+  }
+  async createRegionZDataset(name, srid, fields) {
+    return this.driver.transaction(async () => {
+      const params = fields === void 0 ? { name, srid } : { name, srid, fields };
+      return RegionZDataset.create(this.driver, this.registerRepository, params);
+    });
+  }
+  async createTabularDataset(name, fields) {
+    return this.driver.transaction(async () => {
+      const params = fields === void 0 ? { name } : { name, fields };
+      return TabularDataset.create(this.driver, this.registerRepository, params);
+    });
+  }
+  async createTextDataset(name, srid, fields) {
+    return this.driver.transaction(async () => {
+      const fieldList = fields ?? [];
+      const datasetId = await this.registerRepository.insert({
+        name,
+        kind: "text",
+        srid,
+        idColumnName: "SmID",
+        geometryColumnName: "SmGeometry"
+      });
+      const userColumnDefinitions = fieldList.map((field) => {
+        const nullability = field.nullable ? "" : " NOT NULL";
+        return `"${field.name}" TEXT${nullability}`;
+      });
+      const createTableParts = [
+        `"SmID" INTEGER NOT NULL PRIMARY KEY`,
+        `"SmUserID" INTEGER DEFAULT 0 NOT NULL`,
+        `"SmGeometry" BLOB`,
+        `"SmIndexKey" POLYGON`,
+        ...userColumnDefinitions
+      ];
+      await this.driver.exec(
+        `CREATE TABLE "${name}" (${createTableParts.join(", ")})`
+      );
+      if (fieldList.length > 0) {
+        const fieldInfoRepository = new SmFieldInfoRepository(this.driver);
+        await fieldInfoRepository.insertAll(datasetId, fieldList);
+      }
+      return new TextDataset(this.driver, {
+        id: datasetId,
+        name,
+        kind: "text",
+        tableName: name,
+        srid,
+        objectCount: 0,
+        geometryType: null
+      });
+    });
+  }
+  async createCadDataset(name, fields) {
+    return this.driver.transaction(async () => {
+      const fieldList = fields ?? [];
+      const datasetId = await this.registerRepository.insert({
+        name,
+        kind: "cad",
+        srid: 0,
+        idColumnName: "SmID",
+        geometryColumnName: "SmGeometry"
+      });
+      const userColumnDefinitions = fieldList.map((field) => {
+        const nullability = field.nullable ? "" : " NOT NULL";
+        return `"${field.name}" TEXT${nullability}`;
+      });
+      const createTableParts = [
+        `"SmID" INTEGER NOT NULL PRIMARY KEY`,
+        `"SmUserID" INTEGER DEFAULT 0 NOT NULL`,
+        `"SmGeometry" BLOB`,
+        ...userColumnDefinitions
+      ];
+      await this.driver.exec(
+        `CREATE TABLE "${name}" (${createTableParts.join(", ")})`
+      );
+      if (fieldList.length > 0) {
+        const fieldInfoRepository = new SmFieldInfoRepository(this.driver);
+        await fieldInfoRepository.insertAll(datasetId, fieldList);
+      }
+      return new CadDataset(this.driver, {
+        id: datasetId,
+        name,
+        kind: "cad",
+        tableName: name,
+        srid: 0,
+        objectCount: 0,
+        geometryType: null
+      });
+    });
+  }
+  async close() {
+    await this.driver.close();
+  }
+};
+
+// src/runtime-browser/worker/BrowserWorkerRuntime.ts
+function asReadableDataset(dataset) {
+  return dataset;
+}
+function asWritableDataset(dataset) {
+  return dataset;
+}
+function createSuccess(id, result) {
+  return { id, ok: true, result };
+}
+function createFailure(id, code, message) {
+  return {
+    id,
+    ok: false,
+    error: { code, message }
+  };
+}
+function asObject(value) {
+  if (typeof value === "object" && value !== null) {
+    return value;
+  }
+  return {};
+}
+function parseDatasetName(params) {
+  const value = asObject(params).datasetName;
+  return typeof value === "string" && value.length > 0 ? value : null;
+}
+var VALID_FIELD_TYPES = /* @__PURE__ */ new Set([
+  "boolean",
+  "byte",
+  "int16",
+  "int32",
+  "int64",
+  "single",
+  "double",
+  "date",
+  "binary",
+  "geometry",
+  "char",
+  "ntext",
+  "text",
+  "time"
+]);
+var BrowserWorkerRuntime = class {
+  constructor(options) {
+    this.options = options;
+    __publicField(this, "dataSource", null);
+  }
+  async handle(request) {
+    try {
+      return await this.dispatch(request);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unexpected runtime error.";
+      return createFailure(request.id, "internal_error", message);
+    }
+  }
+  async dispatch(request) {
+    switch (request.method) {
+      case RPC_METHODS.udbxOpen:
+        return this.open(request);
+      case RPC_METHODS.udbxClose:
+        return this.close(request.id);
+      case RPC_METHODS.udbxListDatasets:
+        return this.listDatasets(request.id);
+      case RPC_METHODS.udbxGetDatasetInfo:
+        return this.getDatasetInfo(request);
+      case RPC_METHODS.udbxExportDatabase:
+        return this.exportDatabase(request.id);
+      case RPC_METHODS.udbxImportDatabase:
+        return this.importDatabase(request);
+      case RPC_METHODS.udbxCreatePointDataset:
+        return this.createPointDataset(request);
+      case RPC_METHODS.udbxCreateLineDataset:
+        return this.createLineDataset(request);
+      case RPC_METHODS.udbxCreateRegionDataset:
+        return this.createRegionDataset(request);
+      case RPC_METHODS.udbxCreatePointZDataset:
+        return this.createPointZDataset(request);
+      case RPC_METHODS.udbxCreateLineZDataset:
+        return this.createLineZDataset(request);
+      case RPC_METHODS.udbxCreateRegionZDataset:
+        return this.createRegionZDataset(request);
+      case RPC_METHODS.udbxCreateTabularDataset:
+        return this.createTabularDataset(request);
+      case RPC_METHODS.udbxCreateCadDataset:
+        return this.createCadDataset(request);
+      case RPC_METHODS.datasetGetFields:
+        return this.getFields(request);
+      case RPC_METHODS.datasetGetById:
+        return this.getById(request);
+      case RPC_METHODS.datasetList:
+        return this.listRows(request);
+      case RPC_METHODS.datasetInsert:
+        return this.insert(request);
+      case RPC_METHODS.datasetInsertMany:
+        return this.insertMany(request);
+      case RPC_METHODS.datasetCount:
+        return this.count(request);
+      case RPC_METHODS.datasetUpdate:
+        return this.update(request);
+      case RPC_METHODS.datasetDelete:
+        return this.delete(request);
+      default:
+        return createFailure(
+          request.id,
+          "unsupported_method",
+          `Unsupported RPC method: ${request.method}`
+        );
+    }
+  }
+  async open(request) {
+    if (this.dataSource) {
+      await this.dataSource.close();
+      this.dataSource = null;
+    }
+    const params = request.params ?? {};
+    this.dataSource = await this.options.createDataSource(params);
+    return createSuccess(request.id, { runtime: this.dataSource.runtime });
+  }
+  async close(id) {
+    if (this.dataSource) {
+      await this.dataSource.close();
+      this.dataSource = null;
+    }
+    return createSuccess(id, void 0);
+  }
+  async listDatasets(id) {
+    const ds = this.requireDataSource(id);
+    if (!ds) {
+      return createFailure(id, "not_open", "Datasource has not been opened.");
+    }
+    const rows = await ds.listDatasets();
+    return createSuccess(id, rows);
+  }
+  async getDatasetInfo(request) {
+    const ds = this.requireDataSource(request.id);
+    if (!ds) {
+      return createFailure(
+        request.id,
+        "not_open",
+        "Datasource has not been opened."
+      );
+    }
+    const name = asObject(request.params).name;
+    if (typeof name !== "string" || name.length === 0) {
+      return createFailure(
+        request.id,
+        "invalid_params",
+        "Dataset name is required."
+      );
+    }
+    const dataset = await ds.getDataset(name);
+    return createSuccess(request.id, dataset?.info ?? null);
+  }
+  async exportDatabase(id) {
+    const ds = this.requireDataSource(id);
+    if (!ds) {
+      return createFailure(id, "not_open", "Datasource has not been opened.");
+    }
+    if (typeof ds.__exportDatabase !== "function") {
+      return createFailure(
+        id,
+        "unsupported_operation",
+        "Current runtime does not support database export."
+      );
+    }
+    const binary = await ds.__exportDatabase();
+    return createSuccess(id, binary);
+  }
+  async importDatabase(request) {
+    if (typeof this.options.replaceDataSource !== "function") {
+      return createFailure(
+        request.id,
+        "unsupported_operation",
+        "Current runtime does not support database import."
+      );
+    }
+    const params = asObject(request.params);
+    const binaryRaw = params.binary;
+    let binary;
+    if (binaryRaw instanceof Uint8Array) {
+      binary = binaryRaw;
+    } else if (Array.isArray(binaryRaw)) {
+      binary = new Uint8Array(binaryRaw);
+    } else {
+      return createFailure(
+        request.id,
+        "invalid_params",
+        "`binary` must be a Uint8Array or byte array."
+      );
+    }
+    const preferOpfs = typeof params.preferOpfs === "boolean" ? params.preferOpfs : void 0;
+    if (this.dataSource) {
+      await this.dataSource.close();
+      this.dataSource = null;
+    }
+    this.dataSource = await this.options.replaceDataSource({
+      binary,
+      ...preferOpfs === void 0 ? {} : { preferOpfs }
+    });
+    return createSuccess(request.id, { runtime: this.dataSource.runtime });
+  }
+  async createPointDataset(request) {
+    const ds = this.requireDataSource(request.id);
+    if (!ds) {
+      return createFailure(
+        request.id,
+        "not_open",
+        "Datasource has not been opened."
+      );
+    }
+    const parsed = this.parseCreateDatasetParams(request);
+    if ("error" in parsed) {
+      return parsed.error;
+    }
+    const dataset = await ds.createPointDataset(
+      parsed.params.name,
+      parsed.params.srid,
+      parsed.params.fields
+    );
+    return createSuccess(request.id, dataset.info);
+  }
+  async createLineDataset(request) {
+    const ds = this.requireDataSource(request.id);
+    if (!ds) {
+      return createFailure(
+        request.id,
+        "not_open",
+        "Datasource has not been opened."
+      );
+    }
+    const parsed = this.parseCreateDatasetParams(request);
+    if ("error" in parsed) {
+      return parsed.error;
+    }
+    const dataset = await ds.createLineDataset(
+      parsed.params.name,
+      parsed.params.srid,
+      parsed.params.fields
+    );
+    return createSuccess(request.id, dataset.info);
+  }
+  async createRegionDataset(request) {
+    const ds = this.requireDataSource(request.id);
+    if (!ds) {
+      return createFailure(
+        request.id,
+        "not_open",
+        "Datasource has not been opened."
+      );
+    }
+    const parsed = this.parseCreateDatasetParams(request);
+    if ("error" in parsed) {
+      return parsed.error;
+    }
+    const dataset = await ds.createRegionDataset(
+      parsed.params.name,
+      parsed.params.srid,
+      parsed.params.fields
+    );
+    return createSuccess(request.id, dataset.info);
+  }
+  async createTabularDataset(request) {
+    const ds = this.requireDataSource(request.id);
+    if (!ds) {
+      return createFailure(
+        request.id,
+        "not_open",
+        "Datasource has not been opened."
+      );
+    }
+    const params = asObject(request.params);
+    const name = params.name;
+    if (typeof name !== "string" || name.length === 0) {
+      return createFailure(
+        request.id,
+        "invalid_params",
+        "Dataset name is required."
+      );
+    }
+    const fields = params.fields;
+    const parsedFields = this.parseFieldInfos(request.id, fields);
+    if ("error" in parsedFields) {
+      return parsedFields.error;
+    }
+    const dataset = await ds.createTabularDataset(
+      name,
+      parsedFields.fields
+    );
+    return createSuccess(request.id, dataset.info);
+  }
+  async createPointZDataset(request) {
+    const ds = this.requireDataSource(request.id);
+    if (!ds) {
+      return createFailure(
+        request.id,
+        "not_open",
+        "Datasource has not been opened."
+      );
+    }
+    const parsed = this.parseCreateDatasetParams(request);
+    if ("error" in parsed) {
+      return parsed.error;
+    }
+    const dataset = await ds.createPointZDataset(
+      parsed.params.name,
+      parsed.params.srid,
+      parsed.params.fields
+    );
+    return createSuccess(request.id, dataset.info);
+  }
+  async createLineZDataset(request) {
+    const ds = this.requireDataSource(request.id);
+    if (!ds) {
+      return createFailure(
+        request.id,
+        "not_open",
+        "Datasource has not been opened."
+      );
+    }
+    const parsed = this.parseCreateDatasetParams(request);
+    if ("error" in parsed) {
+      return parsed.error;
+    }
+    const dataset = await ds.createLineZDataset(
+      parsed.params.name,
+      parsed.params.srid,
+      parsed.params.fields
+    );
+    return createSuccess(request.id, dataset.info);
+  }
+  async createRegionZDataset(request) {
+    const ds = this.requireDataSource(request.id);
+    if (!ds) {
+      return createFailure(
+        request.id,
+        "not_open",
+        "Datasource has not been opened."
+      );
+    }
+    const parsed = this.parseCreateDatasetParams(request);
+    if ("error" in parsed) {
+      return parsed.error;
+    }
+    const dataset = await ds.createRegionZDataset(
+      parsed.params.name,
+      parsed.params.srid,
+      parsed.params.fields
+    );
+    return createSuccess(request.id, dataset.info);
+  }
+  async createCadDataset(request) {
+    const ds = this.requireDataSource(request.id);
+    if (!ds) {
+      return createFailure(
+        request.id,
+        "not_open",
+        "Datasource has not been opened."
+      );
+    }
+    const params = asObject(request.params);
+    const name = params.name;
+    if (typeof name !== "string" || name.length === 0) {
+      return createFailure(
+        request.id,
+        "invalid_params",
+        "Dataset name is required."
+      );
+    }
+    const fields = params.fields;
+    const parsedFields = this.parseFieldInfos(request.id, fields);
+    if ("error" in parsedFields) {
+      return parsedFields.error;
+    }
+    const dataset = await ds.createCadDataset(
+      name,
+      parsedFields.fields
+    );
+    return createSuccess(request.id, dataset.info);
+  }
+  async getFields(request) {
+    const dataset = await this.requireDataset(request);
+    if ("error" in dataset) {
+      return dataset.error;
+    }
+    const readable = asReadableDataset(dataset.dataset);
+    const fields = await readable.getFields();
+    return createSuccess(request.id, fields);
+  }
+  async getById(request) {
+    const dataset = await this.requireDataset(request);
+    if ("error" in dataset) {
+      return dataset.error;
+    }
+    const id = asObject(request.params).id;
+    if (typeof id !== "number") {
+      return createFailure(request.id, "invalid_params", "Feature id is required.");
+    }
+    const readable = asReadableDataset(dataset.dataset);
+    const row = await readable.getById(id);
+    return createSuccess(request.id, row);
+  }
+  async listRows(request) {
+    const dataset = await this.requireDataset(request);
+    if ("error" in dataset) {
+      return dataset.error;
+    }
+    const params = asObject(request.params);
+    const options = "options" in params && params.options !== void 0 ? params.options : void 0;
+    const readable = asReadableDataset(dataset.dataset);
+    const rows = await readable.list(options);
+    return createSuccess(request.id, rows);
+  }
+  async insert(request) {
+    const dataset = await this.requireDataset(request);
+    if ("error" in dataset) {
+      return dataset.error;
+    }
+    const writable = asWritableDataset(dataset.dataset);
+    if (typeof writable.insert !== "function") {
+      return createFailure(
+        request.id,
+        "not_writable",
+        `Dataset "${dataset.dataset.info.name}" is not writable.`
+      );
+    }
+    const feature = asObject(request.params).feature;
+    await writable.insert(feature);
+    return createSuccess(request.id, void 0);
+  }
+  async insertMany(request) {
+    const dataset = await this.requireDataset(request);
+    if ("error" in dataset) {
+      return dataset.error;
+    }
+    const writable = asWritableDataset(dataset.dataset);
+    if (typeof writable.insertMany !== "function") {
+      return createFailure(
+        request.id,
+        "not_writable",
+        `Dataset "${dataset.dataset.info.name}" is not writable.`
+      );
+    }
+    const features = asObject(request.params).features;
+    if (!Array.isArray(features)) {
+      return createFailure(
+        request.id,
+        "invalid_params",
+        "`features` must be an array."
+      );
+    }
+    await writable.insertMany(features);
+    return createSuccess(request.id, void 0);
+  }
+  async count(request) {
+    const dataset = await this.requireDataset(request);
+    if ("error" in dataset) {
+      return dataset.error;
+    }
+    const readable = asReadableDataset(dataset.dataset);
+    if (typeof readable.count !== "function") {
+      return createFailure(
+        request.id,
+        "unsupported_operation",
+        `Dataset "${dataset.dataset.info.name}" does not support count.`
+      );
+    }
+    const result = await readable.count();
+    return createSuccess(request.id, result);
+  }
+  async update(request) {
+    const dataset = await this.requireDataset(request);
+    if ("error" in dataset) {
+      return dataset.error;
+    }
+    const writable = asWritableDataset(dataset.dataset);
+    if (typeof writable.update !== "function") {
+      return createFailure(
+        request.id,
+        "not_writable",
+        `Dataset "${dataset.dataset.info.name}" is not writable.`
+      );
+    }
+    const params = asObject(request.params);
+    const feature = params.feature;
+    if (typeof feature !== "object" || feature === null) {
+      return createFailure(
+        request.id,
+        "invalid_params",
+        "`feature` is required."
+      );
+    }
+    const id = feature.id;
+    if (typeof id !== "number") {
+      return createFailure(
+        request.id,
+        "invalid_params",
+        "Feature `id` is required for update."
+      );
+    }
+    const changes = {};
+    if ("geometry" in feature) {
+      changes.geometry = feature.geometry;
+    }
+    if ("attributes" in feature) {
+      changes.attributes = feature.attributes;
+    }
+    await writable.update(id, changes);
+    return createSuccess(request.id, void 0);
+  }
+  async delete(request) {
+    const dataset = await this.requireDataset(request);
+    if ("error" in dataset) {
+      return dataset.error;
+    }
+    const writable = asWritableDataset(dataset.dataset);
+    if (typeof writable.delete !== "function") {
+      return createFailure(
+        request.id,
+        "not_writable",
+        `Dataset "${dataset.dataset.info.name}" is not writable.`
+      );
+    }
+    const id = asObject(request.params).id;
+    if (typeof id !== "number") {
+      return createFailure(request.id, "invalid_params", "Feature id is required.");
+    }
+    await writable.delete(id);
+    return createSuccess(request.id, void 0);
+  }
+  requireDataSource(id) {
+    if (!this.dataSource) {
+      return null;
+    }
+    return this.dataSource;
+  }
+  async requireDataset(request) {
+    const ds = this.requireDataSource(request.id);
+    if (!ds) {
+      return {
+        error: createFailure(
+          request.id,
+          "not_open",
+          "Datasource has not been opened."
+        )
+      };
+    }
+    const datasetName = parseDatasetName(request.params);
+    if (!datasetName) {
+      return {
+        error: createFailure(
+          request.id,
+          "invalid_params",
+          "Dataset name is required."
+        )
+      };
+    }
+    const dataset = await ds.getDataset(datasetName);
+    if (!dataset) {
+      return {
+        error: createFailure(
+          request.id,
+          "dataset_not_found",
+          `Dataset "${datasetName}" does not exist.`
+        )
+      };
+    }
+    return { dataset };
+  }
+  parseCreateDatasetParams(request) {
+    const params = asObject(request.params);
+    const name = params.name;
+    const srid = params.srid;
+    if (typeof name !== "string" || name.length === 0) {
+      return {
+        error: createFailure(
+          request.id,
+          "invalid_params",
+          "Dataset name is required."
+        )
+      };
+    }
+    if (typeof srid !== "number") {
+      return {
+        error: createFailure(request.id, "invalid_params", "Dataset SRID is required.")
+      };
+    }
+    const fields = params.fields;
+    const parsedFields = this.parseFieldInfos(request.id, fields);
+    if ("error" in parsedFields) {
+      return parsedFields;
+    }
+    return {
+      params: {
+        name,
+        srid,
+        ...parsedFields.fields === void 0 ? {} : { fields: parsedFields.fields }
+      }
+    };
+  }
+  parseFieldInfos(id, fields) {
+    if (fields === void 0) {
+      return {};
+    }
+    if (!Array.isArray(fields)) {
+      return {
+        error: createFailure(id, "invalid_params", "`fields` must be an array when provided.")
+      };
+    }
+    const parsed = [];
+    for (const item of fields) {
+      const row = asObject(item);
+      const name = row.name;
+      const fieldType = row.fieldType;
+      if (typeof name !== "string" || name.length === 0) {
+        return {
+          error: createFailure(id, "invalid_params", "Field name is required.")
+        };
+      }
+      if (typeof fieldType !== "string" || !VALID_FIELD_TYPES.has(fieldType)) {
+        return {
+          error: createFailure(id, "invalid_params", `Unsupported field type: ${String(fieldType)}`)
+        };
+      }
+      const info = {
+        name,
+        fieldType
+      };
+      if ("alias" in row && typeof row.alias === "string") {
+        info.alias = row.alias;
+      }
+      if ("required" in row && typeof row.required === "boolean") {
+        info.required = row.required;
+      }
+      if ("nullable" in row && typeof row.nullable === "boolean") {
+        info.nullable = row.nullable;
+      }
+      if ("defaultValue" in row) {
+        info.defaultValue = row.defaultValue;
+      }
+      parsed.push(info);
+    }
+    return { fields: parsed };
+  }
+};
+function createWorkerMessageHandler(runtime, host) {
+  return async (event) => {
+    const data = event.data;
+    if (typeof data !== "object" || data === null) {
+      return;
+    }
+    if (!("id" in data) || !("method" in data)) {
+      return;
+    }
+    const response = await runtime.handle(data);
+    host.postMessage(response);
+  };
+}
+
+// src/runtime-browser/worker/createBrowserWorkerRuntime.ts
+function createBrowserWorkerRuntime(options) {
+  const createManagedDataSource = async (params) => {
+    const driver = await options.createDriver();
+    const target = resolveBrowserSqlOpenTarget({
+      ...options.openTarget,
+      ...params.preferOpfs === void 0 ? {} : { preferOpfs: params.preferOpfs }
+    });
+    if (params.binary !== void 0) {
+      if (!("importDatabase" in driver) || typeof driver.importDatabase !== "function") {
+        throw new Error("Current browser SQL driver does not support import.");
+      }
+      await driver.importDatabase(target, params.binary);
+    }
+    await driver.open(target);
+    if (params.binary === void 0) {
+      await UdbxSchemaInitializer.ensureInitialized(driver);
+    }
+    const dataSource = new UdbxDataSource(driver, "browser");
+    if ("exportDatabase" in driver && typeof driver.exportDatabase === "function") {
+      dataSource.__exportDatabase = () => driver.exportDatabase();
+    }
+    return dataSource;
+  };
+  return new BrowserWorkerRuntime({
+    createDataSource: ({ preferOpfs }) => createManagedDataSource({
+      ...preferOpfs === void 0 ? {} : { preferOpfs }
+    }),
+    replaceDataSource: ({ preferOpfs, binary }) => createManagedDataSource({
+      binary: binary instanceof Uint8Array ? binary : new Uint8Array(binary),
+      ...preferOpfs === void 0 ? {} : { preferOpfs }
+    })
+  });
+}
+
+// src/runtime-browser/worker/installSqliteWasmWorkerRuntime.ts
+function installSqliteWasmWorkerRuntime(globalScope, options = {}) {
+  const runtime = createBrowserWorkerRuntime({
+    createDriver: () => new BrowserSqliteDriver(createSqliteWasmAdapter(options.sqlite)),
+    ...options.openTarget === void 0 ? {} : { openTarget: options.openTarget }
+  });
+  const handler = createWorkerMessageHandler(runtime, {
+    postMessage: (message) => globalScope.postMessage(message)
+  });
+  globalScope.addEventListener("message", (event) => {
+    void handler(event);
+  });
+}
+
+// src/runtime-browser/worker/index.ts
+function installBrowserWorkerRuntime(globalScope, runtime) {
+  const handler = createWorkerMessageHandler(runtime, {
+    postMessage: (message) => globalScope.postMessage(message)
+  });
+  globalScope.addEventListener("message", (event) => {
+    void handler(event);
+  });
+}
+function installDefaultBrowserWorkerRuntime(globalScope, options) {
+  const runtime = createBrowserWorkerRuntime(options);
+  installBrowserWorkerRuntime(globalScope, runtime);
+  return runtime;
+}
+
+// src/runtime-browser/fs/browserFileIO.ts
+function toArrayBufferView(binary) {
+  const view = new Uint8Array(binary.byteLength);
+  view.set(binary);
+  return view;
+}
+function supportsFileSystemAccess(probe = globalThis) {
+  return typeof probe.showOpenFilePicker === "function" && typeof probe.showSaveFilePicker === "function";
+}
+async function readBlobAsUint8Array(blob) {
+  return new Uint8Array(await blob.arrayBuffer());
+}
+function createUdbxBlob(binary) {
+  return new Blob([toArrayBufferView(binary)], { type: "application/octet-stream" });
+}
+async function writeBinaryToFileHandle(handle, binary) {
+  const writable = await handle.createWritable();
+  try {
+    await writable.write(toArrayBufferView(binary));
+  } finally {
+    await writable.close();
+  }
+}
+function downloadBinaryFile(binary, filename, env = {
+  document: globalThis.document,
+  URL: globalThis.URL
+}) {
+  const blob = createUdbxBlob(binary);
+  const url = env.URL.createObjectURL(blob);
+  const anchor = env.document.createElement("a");
+  anchor.href = url;
+  anchor.download = filename;
+  anchor.style.display = "none";
+  env.document.body.appendChild(anchor);
+  anchor.click();
+  env.document.body.removeChild(anchor);
+  env.URL.revokeObjectURL(url);
+}
+async function saveBinaryWithPickerOrDownload(binary, filename, options = {}) {
+  const probe = options.pickerProbe ?? globalThis;
+  if (typeof probe.showSaveFilePicker === "function") {
+    const handle = await probe.showSaveFilePicker({
+      suggestedName: filename
+    });
+    await writeBinaryToFileHandle(handle, binary);
+    return "picker";
+  }
+  if (options.downloadEnv === void 0) {
+    downloadBinaryFile(binary, filename);
+  } else {
+    downloadBinaryFile(binary, filename, options.downloadEnv);
+  }
+  return "download";
+}
+
+// src/runtime-browser/fs/browserWorkspace.ts
+async function importUdbxFromFile(dataSource, file, options = {}) {
+  const binary = await readBlobAsUint8Array(file);
+  await dataSource.importDatabase(binary, options);
+}
+async function exportUdbxToBlob(dataSource) {
+  const binary = await dataSource.exportDatabase();
+  return createUdbxBlob(binary);
+}
+async function saveUdbxToFileHandle(dataSource, handle) {
+  const binary = await dataSource.exportDatabase();
+  await writeBinaryToFileHandle(handle, binary);
+}
+async function downloadUdbxFile(dataSource, filename) {
+  const binary = await dataSource.exportDatabase();
+  downloadBinaryFile(binary, filename);
+}
+async function saveUdbxWithPickerOrDownload(dataSource, filename) {
+  const binary = await dataSource.exportDatabase();
+  return saveBinaryWithPickerOrDownload(binary, filename);
+}
+
+// src/runtime-browser/index.ts
+function resolveWorker(options) {
+  if (options.workerFactory) {
+    return options.workerFactory();
+  }
+  if (!options.workerUrl) {
+    throw new Error(
+      "Browser worker URL is required. Provide `workerUrl` or `workerFactory`."
+    );
+  }
+  if (typeof Worker === "undefined") {
+    throw new Error("Worker API is unavailable in this environment.");
+  }
+  return new Worker(options.workerUrl, { type: "module" });
+}
+async function createBrowserUdbx(options = {}) {
+  const worker = resolveWorker(options);
+  const transport = new BrowserWorkerTransport(worker);
+  const connectOptions = options.preferOpfs === void 0 ? {} : { preferOpfs: options.preferOpfs };
+  const client = await BrowserUdbxClient.connect(transport, {
+    ...connectOptions
+  });
+  return client;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BrowserSqliteDriver,
+  createBrowserUdbx,
+  createBrowserWorkerRuntime,
+  createSqliteWasmAdapter,
+  createUdbxBlob,
+  downloadBinaryFile,
+  downloadUdbxFile,
+  exportUdbxToBlob,
+  importUdbxFromFile,
+  installBrowserWorkerRuntime,
+  installDefaultBrowserWorkerRuntime,
+  installSqliteWasmWorkerRuntime,
+  isOpfsAvailable,
+  readBlobAsUint8Array,
+  resolveBrowserSqlOpenTarget,
+  saveBinaryWithPickerOrDownload,
+  saveUdbxToFileHandle,
+  saveUdbxWithPickerOrDownload,
+  supportsFileSystemAccess,
+  writeBinaryToFileHandle
+});
+//# sourceMappingURL=index.cjs.map