teryt-mcp 0.1.0

package/dist/chunk-YEPFIU35.js

@@ -0,0 +1,2434 @@
+// src/features/server-status/application/get-server-status.ts
+function getServerStatus(input) {
+  return {
+    serverName: "teryt-mcp",
+    serverVersion: "0.1.0",
+    frameworkVersion: input.frameworkVersion,
+    transport: input.transport,
+    dataDir: input.dataDir,
+    database: {
+      status: "not_configured"
+    }
+  };
+}
+
+// src/features/server-status/mcp/server-status.tool.ts
+import { defineTool, mcpCraftmanCoreVersion } from "@mcp-craftman/core";
+function createServerStatusTool(input) {
+  return defineTool({
+    name: "server_status",
+    description: "Returns server runtime status.",
+    policy: "read",
+    returnsStructuredContent: true,
+    outputSchema: {
+      type: "object",
+      properties: {
+        serverName: {
+          type: "string"
+        },
+        serverVersion: {
+          type: "string"
+        },
+        frameworkVersion: {
+          type: "string"
+        },
+        transport: {
+          type: "string",
+          enum: ["stdio", "http"]
+        },
+        dataDir: {
+          type: "string"
+        },
+        database: {
+          type: "object",
+          properties: {
+            status: {
+              type: "string",
+              enum: ["not_configured"]
+            }
+          },
+          required: ["status"]
+        }
+      },
+      required: ["serverName", "serverVersion", "frameworkVersion", "transport", "dataDir", "database"]
+    },
+    annotations: {
+      readOnlyHint: true
+    },
+    handler: () => ({
+      structuredContent: getServerStatus({
+        ...input,
+        frameworkVersion: mcpCraftmanCoreVersion
+      })
+    })
+  });
+}
+
+// src/app.ts
+import { createMcpApp } from "@mcp-craftman/core";
+import { loadRuntimeConfig } from "@mcp-craftman/node";
+
+// src/features/get-place/infrastructure/in-memory-place-details-repository.ts
+var fixturePlaces = [
+  {
+    id: "0009876",
+    name: "Boles\u0142awiec",
+    stateDate: "2026-01-01",
+    unitId: "02-01-01-1"
+  },
+  {
+    id: "0012345",
+    name: "Stara Wie\u015B",
+    stateDate: "2026-01-01",
+    unitId: "02-01-02-2"
+  }
+];
+var InMemoryPlaceDetailsRepository = class {
+  async getPlace(id) {
+    return fixturePlaces.find((place) => place.id === id) ?? null;
+  }
+};
+
+// src/features/get-street/infrastructure/in-memory-street-details-repository.ts
+var fixtureStreets = [
+  {
+    code: "0000123",
+    id: "0009876-0000123",
+    name: "Marsza\u0142kowska",
+    placeId: "0009876",
+    stateDate: "2026-01-01"
+  },
+  {
+    code: "0000456",
+    id: "0009876-0000456",
+    name: "Rynek",
+    placeId: "0009876",
+    stateDate: "2026-01-01"
+  }
+];
+var InMemoryStreetDetailsRepository = class {
+  async getStreet(id) {
+    return fixtureStreets.find((street) => street.id === id || street.code === id) ?? null;
+  }
+};
+
+// src/features/get-unit/infrastructure/in-memory-unit-details-repository.ts
+var fixtureStateDate = "2026-01-01";
+var fixtureUnits = [
+  {
+    id: "02",
+    name: "DOLNO\u015AL\u0104SKIE",
+    stateDate: fixtureStateDate,
+    type: "wojew\xF3dztwo"
+  },
+  {
+    id: "02-01-01-1",
+    name: "Boles\u0142awiec",
+    stateDate: fixtureStateDate,
+    type: "gmina miejska"
+  },
+  {
+    id: "02-01-02-2",
+    name: "Boles\u0142awiec",
+    stateDate: fixtureStateDate,
+    type: "gmina wiejska"
+  }
+];
+var InMemoryUnitDetailsRepository = class {
+  async getUnit(id) {
+    return fixtureUnits.find((unit) => unit.id === id) ?? null;
+  }
+};
+
+// src/features/resolve-address/infrastructure/in-memory-address-repository.ts
+var fixturePlace = {
+  id: "0009876",
+  name: "Boles\u0142awiec"
+};
+var fixtureStateDate2 = "2026-01-01";
+var fixtureUnit = {
+  id: "02-01-01-1",
+  name: "Boles\u0142awiec",
+  type: "gmina miejska"
+};
+var fixtureAddresses = [
+  {
+    id: "0009876-0000123",
+    place: fixturePlace,
+    stateDate: fixtureStateDate2,
+    street: {
+      code: "0000123",
+      id: "0009876-0000123",
+      name: "Marsza\u0142kowska"
+    },
+    unit: fixtureUnit
+  },
+  {
+    id: "0009876-0000456",
+    place: fixturePlace,
+    stateDate: fixtureStateDate2,
+    street: {
+      code: "0000456",
+      id: "0009876-0000456",
+      name: "Rynek"
+    },
+    unit: fixtureUnit
+  }
+];
+var InMemoryAddressRepository = class {
+  async listAddresses() {
+    return fixtureAddresses;
+  }
+};
+
+// src/features/search-places/infrastructure/in-memory-place-repository.ts
+var fixtureStateDate3 = "2026-01-01";
+var fixturePlaces2 = [
+  {
+    id: "0009876",
+    name: "Boles\u0142awiec",
+    stateDate: fixtureStateDate3,
+    unitId: "02-01-01-1"
+  },
+  {
+    id: "0011111",
+    name: "Krak\xF3w",
+    stateDate: fixtureStateDate3,
+    unitId: "12-61-01-1"
+  },
+  {
+    id: "0012222",
+    name: "Warszawa",
+    stateDate: fixtureStateDate3,
+    unitId: "14-65-01-1"
+  },
+  {
+    id: "0012345",
+    name: "Stara Wie\u015B",
+    stateDate: fixtureStateDate3,
+    unitId: "02-01-02-2"
+  },
+  {
+    id: "0013333",
+    name: "D\u0105browa",
+    stateDate: fixtureStateDate3,
+    unitId: "24-01-01-2"
+  }
+];
+var InMemoryPlaceRepository = class {
+  async listPlaces() {
+    return fixturePlaces2;
+  }
+};
+
+// src/features/search-streets/infrastructure/in-memory-street-repository.ts
+var fixtureStreets2 = [
+  {
+    code: "0000123",
+    id: "0009876-0000123",
+    name: "Marsza\u0142kowska",
+    placeId: "0009876",
+    stateDate: "2026-01-01"
+  },
+  {
+    code: "0000456",
+    id: "0009876-0000456",
+    name: "Rynek",
+    placeId: "0009876",
+    stateDate: "2026-01-01"
+  }
+];
+var InMemoryStreetRepository = class {
+  async listStreets() {
+    return fixtureStreets2;
+  }
+};
+
+// src/features/search-units/infrastructure/in-memory-unit-repository.ts
+var fixtureStateDate4 = "2026-01-01";
+var fixtureUnits2 = [
+  {
+    id: "02",
+    name: "DOLNO\u015AL\u0104SKIE",
+    stateDate: fixtureStateDate4,
+    type: "wojew\xF3dztwo"
+  },
+  {
+    id: "02-01-01-1",
+    name: "Boles\u0142awiec",
+    stateDate: fixtureStateDate4,
+    type: "gmina miejska"
+  },
+  {
+    id: "02-01-02-2",
+    name: "Boles\u0142awiec",
+    stateDate: fixtureStateDate4,
+    type: "gmina wiejska"
+  }
+];
+var InMemoryUnitRepository = class {
+  async listUnits() {
+    return fixtureUnits2;
+  }
+};
+
+// src/features/source-status/infrastructure/eteryt-source-catalog.ts
+var SOURCE_URL = "https://eteryt.stat.gov.pl/eTeryt/";
+var EterytSourceCatalog = class {
+  async listDatasets() {
+    return [
+      {
+        code: "TERC",
+        name: "Territorial units",
+        sourceUrl: SOURCE_URL
+      },
+      {
+        code: "SIMC",
+        name: "Localities",
+        sourceUrl: SOURCE_URL
+      },
+      {
+        code: "ULIC",
+        name: "Streets",
+        sourceUrl: SOURCE_URL
+      },
+      {
+        code: "WMRODZ",
+        name: "Locality type dictionary",
+        sourceUrl: SOURCE_URL
+      }
+    ];
+  }
+};
+
+// src/features/source-status/infrastructure/json-manifest-store.ts
+import { readFile } from "fs/promises";
+import { join } from "path";
+var JsonManifestStore = class {
+  constructor(dataDir) {
+    this.dataDir = dataDir;
+  }
+  dataDir;
+  async getSnapshot(dataset) {
+    try {
+      const content = await readFile(join(this.dataDir, "source-manifest.json"), "utf8");
+      const manifest = JSON.parse(content);
+      return manifest.snapshots?.find((snapshot) => snapshot.dataset === dataset);
+    } catch (error) {
+      if (isMissingFile(error)) {
+        return void 0;
+      }
+      throw error;
+    }
+  }
+};
+function isMissingFile(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+
+// src/features/sync-database/infrastructure/eteryt-source.ts
+var DOWNLOAD_PAGE_URL = "https://eteryt.stat.gov.pl/eTeryt/rejestr_teryt/udostepnianie_danych/baza_teryt/uzytkownicy_indywidualni/pobieranie/pliki_pelne.aspx";
+var eventTargets = {
+  SIMC: "ctl00$body$BSIMCUrzedowyPobierz",
+  TERC: "ctl00$body$BTERCAdresowyPobierz",
+  ULIC: "ctl00$body$BULICUrzedowyPobierz",
+  WMRODZ: "ctl00$body$BRodzMiejPobierz"
+};
+var EterytSource = class {
+  constructor(fetchFn = fetch) {
+    this.fetchFn = fetchFn;
+  }
+  fetchFn;
+  async download(dataset) {
+    const page = await this.fetchPage();
+    const content = await this.postDownload(page, eventTargets[dataset]);
+    return {
+      content,
+      dataset,
+      sourceUrl: `${DOWNLOAD_PAGE_URL}#${dataset}`,
+      stateDate: "unknown"
+    };
+  }
+  async fetchPage() {
+    const response = await this.fetchFn(DOWNLOAD_PAGE_URL);
+    if (!response.ok) {
+      throw new Error(`Cannot load eTeryt download page: HTTP ${response.status}.`);
+    }
+    return {
+      cookies: extractCookies(response.headers),
+      html: await response.text()
+    };
+  }
+  async postDownload(page, eventTarget) {
+    const form = parseHiddenInputs(page.html);
+    form.set("__EVENTTARGET", eventTarget);
+    form.set("__EVENTARGUMENT", "");
+    const response = await this.fetchFn(DOWNLOAD_PAGE_URL, {
+      body: form,
+      headers: {
+        "content-type": "application/x-www-form-urlencoded",
+        ...page.cookies ? { cookie: page.cookies } : {}
+      },
+      method: "POST"
+    });
+    if (!response.ok) {
+      throw new Error(`Cannot download eTeryt dataset: HTTP ${response.status}.`);
+    }
+    const contentType = response.headers.get("content-type") ?? "";
+    if (contentType.includes("text/html")) {
+      throw new Error("eTeryt returned HTML instead of a dataset file.");
+    }
+    return new Uint8Array(await response.arrayBuffer());
+  }
+};
+function parseHiddenInputs(html) {
+  const form = new URLSearchParams();
+  for (const input of findInputTags(html)) {
+    const name = getAttribute(input, "name");
+    if (getAttribute(input, "type")?.toLowerCase() === "hidden" && name) {
+      form.set(name, decodeHtmlEntities(getAttribute(input, "value") ?? ""));
+    }
+  }
+  return form;
+}
+function findInputTags(html) {
+  const inputs = [];
+  let searchFrom = 0;
+  let start = html.toLowerCase().indexOf("<input", searchFrom);
+  while (start >= 0) {
+    const end = html.indexOf(">", start);
+    if (end < 0) {
+      break;
+    }
+    inputs.push(html.slice(start, end + 1));
+    searchFrom = end + 1;
+    start = html.toLowerCase().indexOf("<input", searchFrom);
+  }
+  return inputs;
+}
+function getAttribute(input, name) {
+  const marker = `${name}=`;
+  const markerIndex = input.toLowerCase().indexOf(marker.toLowerCase());
+  if (markerIndex < 0) {
+    return null;
+  }
+  const quote = input[markerIndex + marker.length];
+  if (quote !== '"' && quote !== "'") {
+    return null;
+  }
+  const valueStart = markerIndex + marker.length + 1;
+  const valueEnd = input.indexOf(quote, valueStart);
+  if (valueEnd < 0) {
+    return null;
+  }
+  return input.slice(valueStart, valueEnd);
+}
+function decodeHtmlEntities(value) {
+  return value.replaceAll("&quot;", '"').replaceAll("&#39;", "'").replaceAll("&amp;", "&").replaceAll("&lt;", "<").replaceAll("&gt;", ">");
+}
+function extractCookies(headers) {
+  const rawCookies = headers.get("set-cookie");
+  if (!rawCookies) {
+    return "";
+  }
+  return splitSetCookieHeader(rawCookies).map((cookie) => cookie.split(";")[0]?.trim()).filter((cookie) => cookie).join("; ");
+}
+function splitSetCookieHeader(value) {
+  const cookies = [];
+  let start = 0;
+  for (let index = 0; index < value.length; index += 1) {
+    if (value[index] !== "," || !isCookieBoundary(value, index + 1)) {
+      continue;
+    }
+    cookies.push(value.slice(start, index));
+    start = index + 1;
+  }
+  cookies.push(value.slice(start));
+  return cookies;
+}
+function isCookieBoundary(value, start) {
+  let index = start;
+  while (value[index] === " ") {
+    index += 1;
+  }
+  const semicolonIndex = value.indexOf(";", index);
+  const equalsIndex = value.indexOf("=", index);
+  return equalsIndex >= 0 && (semicolonIndex < 0 || equalsIndex < semicolonIndex);
+}
+
+// src/features/sync-database/infrastructure/file-lock-store.ts
+import { join as join2 } from "path";
+import { withLock } from "@mcp-craftman/node";
+var FileLockStore = class {
+  constructor(dataDir) {
+    this.dataDir = dataDir;
+  }
+  dataDir;
+  async withSyncLock(callback) {
+    return withLock(join2(this.dataDir, "sync.lock"), callback);
+  }
+};
+
+// src/features/sync-database/infrastructure/json-manifest-store.ts
+import { join as join3 } from "path";
+import { atomicWrite } from "@mcp-craftman/node";
+var JsonSyncManifestStore = class {
+  constructor(dataDir) {
+    this.dataDir = dataDir;
+  }
+  dataDir;
+  async writeSnapshot(snapshot) {
+    await atomicWrite(join3(this.dataDir, "sync-manifest.json"), `${JSON.stringify(snapshot, null, 2)}
+`);
+  }
+};
+
+// src/features/sync-database/infrastructure/local-file-store.ts
+import { access } from "fs/promises";
+import { join as join4 } from "path";
+import { atomicWrite as atomicWrite2 } from "@mcp-craftman/node";
+var LocalFileStore = class {
+  constructor(dataDir) {
+    this.dataDir = dataDir;
+  }
+  dataDir;
+  async databaseExists() {
+    try {
+      await access(this.databasePath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async swapDatabase(content) {
+    await atomicWrite2(this.databasePath, content);
+    return this.databasePath;
+  }
+  get databasePath() {
+    return join4(this.dataDir, "teryt.sqlite");
+  }
+};
+
+// src/features/sync-database/infrastructure/sqlite-database-builder.ts
+import initSqlJs from "sql.js";
+
+// src/features/sync-database/application/importers/teryt-source-file.ts
+import { TextDecoder as TextDecoder2 } from "util";
+
+// src/features/sync-database/application/importers/teryt-csv.ts
+import { createHash } from "crypto";
+var requiredColumns = {
+  SIMC: ["WOJ", "POW", "GMI", "RODZ_GMI", "RM", "MZ", "NAZWA", "SYM", "SYMPOD", "STAN_NA"],
+  TERC: ["WOJ", "POW", "GMI", "RODZ", "NAZWA", "NAZDOD", "STAN_NA"],
+  ULIC: ["WOJ", "POW", "GMI", "RODZ_GMI", "SYM", "SYM_UL", "CECHA", "NAZWA_1", "NAZWA_2", "STAN_NA"],
+  WMRODZ: ["RM", "NAZWA_RM", "STAN_NA"]
+};
+var detectionColumns = {
+  SIMC: ["SYM", "SYMPOD", "RM"],
+  TERC: ["RODZ"],
+  ULIC: ["SYM_UL", "CECHA", "NAZWA_1"],
+  WMRODZ: ["NAZWA_RM"]
+};
+function importTerytCsv(content, options = {}) {
+  const [headerLine, ...recordLines] = content.trim().split(/\r?\n/);
+  if (!headerLine) {
+    throw new Error("TERYT CSV is empty.");
+  }
+  validateSha256(content, options.expectedSha256);
+  const columns = parseCsvLine(headerLine);
+  const dataset = detectDataset(columns);
+  validateColumns(dataset, columns);
+  const rows = recordLines.filter(Boolean).map((line) => {
+    const values = parseCsvLine(line);
+    return {
+      values: Object.fromEntries(columns.map((column, index) => [column, values[index] ?? ""])),
+      dataset
+    };
+  });
+  const stateDate = validateStateDate(dataset, rows);
+  validateRecordCount(dataset, rows.length, options.minRecordCount);
+  return {
+    recordCount: rows.length,
+    columns,
+    dataset,
+    rows,
+    stateDate
+  };
+}
+function detectDataset(columns) {
+  const columnSet = new Set(columns);
+  const matches = Object.entries(detectionColumns).filter(
+    ([, required]) => required.every((column) => columnSet.has(column))
+  );
+  if (matches.length !== 1) {
+    throw new Error(`Cannot detect TERYT dataset from columns: ${columns.join(", ")}`);
+  }
+  return matches[0][0];
+}
+function validateColumns(dataset, columns) {
+  const columnSet = new Set(columns);
+  const missing = requiredColumns[dataset].filter((column) => !columnSet.has(column));
+  if (missing.length > 0) {
+    throw new Error(`Missing ${dataset} columns: ${missing.join(", ")}`);
+  }
+}
+function validateStateDate(dataset, rows) {
+  const stateDates = new Set(rows.map((row) => row.values.STAN_NA).filter(Boolean));
+  if (stateDates.size !== 1) {
+    throw new Error(`${dataset} must contain exactly one STAN_NA value.`);
+  }
+  const [stateDate] = stateDates;
+  if (!stateDate || !isIsoDate(stateDate)) {
+    throw new Error(`${dataset} has invalid STAN_NA value.`);
+  }
+  return stateDate;
+}
+function validateRecordCount(dataset, recordCount, minRecordCount = 1) {
+  if (recordCount < minRecordCount) {
+    throw new Error(`${dataset} recordCount ${recordCount} is below minimum ${minRecordCount}.`);
+  }
+}
+function validateSha256(content, expectedSha256) {
+  if (!expectedSha256) {
+    return;
+  }
+  const actualSha256 = createHash("sha256").update(content).digest("hex");
+  if (actualSha256 !== expectedSha256) {
+    throw new Error(`TERYT CSV sha256 mismatch: expected ${expectedSha256}, got ${actualSha256}.`);
+  }
+}
+function parseCsvLine(line) {
+  const delimiter = line.includes(";") ? ";" : ",";
+  const values = [];
+  let current = "";
+  let quoted = false;
+  for (const character of line) {
+    if (character === '"') {
+      quoted = !quoted;
+    } else if (character === delimiter && !quoted) {
+      values.push(current);
+      current = "";
+    } else {
+      current += character;
+    }
+  }
+  values.push(current);
+  return values;
+}
+function isIsoDate(value) {
+  const [year, month, day] = value.split("-");
+  return isNumberSegment(year, 4) && isNumberSegment(month, 2) && isNumberSegment(day, 2);
+}
+function isNumberSegment(value, length) {
+  return value?.length === length && [...value].every((character) => character >= "0" && character <= "9");
+}
+
+// src/features/sync-database/application/importers/teryt-zip.ts
+import { unzipSync } from "fflate";
+function importTerytZip(content) {
+  const entries = unzipSync(content);
+  const csvEntry = Object.entries(entries).find(([name]) => name.toLowerCase().endsWith(".csv"));
+  if (!csvEntry) {
+    throw new Error("TERYT ZIP does not contain a CSV file.");
+  }
+  const [, csvContent] = csvEntry;
+  return importTerytCsv(new TextDecoder().decode(csvContent));
+}
+
+// src/features/sync-database/application/importers/teryt-source-file.ts
+var decoder = new TextDecoder2();
+function importTerytSourceFile(sourceFile) {
+  if (isZip(sourceFile.content)) {
+    return importTerytZip(sourceFile.content);
+  }
+  return importTerytCsv(decoder.decode(sourceFile.content));
+}
+function isZip(content) {
+  return content[0] === 80 && content[1] === 75;
+}
+
+// src/features/sync-database/application/importers/teryt-relations.ts
+function validateTerytRelations(imports) {
+  const simcRows = getRows(imports, "SIMC");
+  const tercUnitIds = new Set(getRows(imports, "TERC").map((row) => createUnitId(row.values)));
+  const simcIds = new Set(simcRows.map((row) => row.values.SYM).filter(Boolean));
+  validateSimcUnits(simcRows, tercUnitIds);
+  validateUlicPlaces(getRows(imports, "ULIC"), simcIds);
+}
+function validateSimcUnits(simcRows, tercUnitIds) {
+  for (const row of simcRows) {
+    const unitId = createUnitId(row.values);
+    if (!tercUnitIds.has(unitId)) {
+      throw new Error(`SIMC ${row.values.SYM ?? "<unknown>"} references missing TERC unit ${unitId}.`);
+    }
+  }
+}
+function validateUlicPlaces(ulicRows, simcIds) {
+  for (const row of ulicRows) {
+    const placeId = row.values.SYM;
+    if (!placeId || !simcIds.has(placeId)) {
+      throw new Error(`ULIC ${row.values.SYM_UL ?? "<unknown>"} references missing SIMC place ${placeId ?? "<empty>"}.`);
+    }
+  }
+}
+function getRows(imports, dataset) {
+  return imports.find((item) => item.dataset === dataset)?.rows ?? [];
+}
+function createUnitId(values) {
+  return [values.WOJ ?? "", values.POW ?? "", values.GMI ?? "", values.RODZ ?? values.RODZ_GMI ?? ""].join("-");
+}
+
+// src/features/sync-database/application/importers/sqlite-schema.ts
+var terytSqliteSchema = [
+  `CREATE TABLE raw_terc (
+    WOJ TEXT,
+    POW TEXT,
+    GMI TEXT,
+    RODZ TEXT,
+    NAZWA TEXT,
+    NAZDOD TEXT,
+    STAN_NA TEXT
+  )`,
+  `CREATE TABLE raw_simc (
+    WOJ TEXT,
+    POW TEXT,
+    GMI TEXT,
+    RODZ_GMI TEXT,
+    RM TEXT,
+    MZ TEXT,
+    NAZWA TEXT,
+    SYM TEXT,
+    SYMPOD TEXT,
+    STAN_NA TEXT
+  )`,
+  `CREATE TABLE raw_ulic (
+    WOJ TEXT,
+    POW TEXT,
+    GMI TEXT,
+    RODZ_GMI TEXT,
+    SYM TEXT,
+    SYM_UL TEXT,
+    CECHA TEXT,
+    NAZWA_1 TEXT,
+    NAZWA_2 TEXT,
+    STAN_NA TEXT
+  )`,
+  `CREATE TABLE raw_wmrodz (
+    RM TEXT,
+    NAZWA_RM TEXT,
+    STAN_NA TEXT
+  )`,
+  `CREATE TABLE units (
+    id TEXT PRIMARY KEY,
+    WOJ TEXT,
+    POW TEXT,
+    GMI TEXT,
+    RODZ TEXT,
+    name TEXT,
+    type TEXT,
+    stateDate TEXT
+  )`,
+  `CREATE TABLE places (
+    id TEXT PRIMARY KEY,
+    SYM TEXT,
+    SYMPOD TEXT,
+    RM TEXT,
+    name TEXT,
+    unitId TEXT,
+    stateDate TEXT
+  )`,
+  `CREATE TABLE streets (
+    id TEXT PRIMARY KEY,
+    SYM TEXT,
+    SYM_UL TEXT,
+    name TEXT,
+    placeId TEXT,
+    stateDate TEXT
+  )`,
+  `CREATE TABLE metadata (
+    key TEXT PRIMARY KEY,
+    value TEXT NOT NULL
+  )`,
+  "CREATE VIRTUAL TABLE units_fts USING fts5(name, content='units', content_rowid='rowid')",
+  "CREATE VIRTUAL TABLE places_fts USING fts5(name, content='places', content_rowid='rowid')",
+  "CREATE VIRTUAL TABLE streets_fts USING fts5(name, content='streets', content_rowid='rowid')"
+];
+
+// src/features/sync-database/infrastructure/sqlite-search-tables.ts
+function insertSearchTables(db, imports) {
+  const terc = findImport(imports, "TERC");
+  const simc = findImport(imports, "SIMC");
+  const ulic = findImport(imports, "ULIC");
+  insertUnits(db, terc.rows);
+  insertPlaces(db, simc.rows);
+  insertStreets(db, ulic.rows);
+  db.run("INSERT INTO units_fts(rowid, name) SELECT rowid, name FROM units");
+  db.run("INSERT INTO places_fts(rowid, name) SELECT rowid, name FROM places");
+  db.run("INSERT INTO streets_fts(rowid, name) SELECT rowid, name FROM streets");
+}
+function insertUnits(db, rows) {
+  const statement = db.prepare(
+    "INSERT INTO units (id, WOJ, POW, GMI, RODZ, name, type, stateDate) VALUES (?, ?, ?, ?, ?, ?, ?, ?)"
+  );
+  try {
+    for (const row of rows) {
+      statement.run([
+        createUnitId2(row.values),
+        row.values.WOJ ?? "",
+        row.values.POW ?? "",
+        row.values.GMI ?? "",
+        row.values.RODZ ?? "",
+        row.values.NAZWA ?? "",
+        row.values.NAZDOD ?? "",
+        row.values.STAN_NA ?? ""
+      ]);
+    }
+  } finally {
+    statement.free();
+  }
+}
+function insertPlaces(db, rows) {
+  const statement = db.prepare(
+    "INSERT INTO places (id, SYM, SYMPOD, RM, name, unitId, stateDate) VALUES (?, ?, ?, ?, ?, ?, ?)"
+  );
+  try {
+    for (const row of rows) {
+      statement.run([
+        row.values.SYM ?? "",
+        row.values.SYM ?? "",
+        row.values.SYMPOD ?? "",
+        row.values.RM ?? "",
+        row.values.NAZWA ?? "",
+        createUnitId2(row.values),
+        row.values.STAN_NA ?? ""
+      ]);
+    }
+  } finally {
+    statement.free();
+  }
+}
+function insertStreets(db, rows) {
+  const statement = db.prepare(
+    "INSERT INTO streets (id, SYM, SYM_UL, name, placeId, stateDate) VALUES (?, ?, ?, ?, ?, ?)"
+  );
+  try {
+    for (const row of rows) {
+      statement.run([
+        `${row.values.SYM ?? ""}-${row.values.SYM_UL ?? ""}`,
+        row.values.SYM ?? "",
+        row.values.SYM_UL ?? "",
+        [row.values.CECHA, row.values.NAZWA_1, row.values.NAZWA_2].filter(Boolean).join(" "),
+        row.values.SYM ?? "",
+        row.values.STAN_NA ?? ""
+      ]);
+    }
+  } finally {
+    statement.free();
+  }
+}
+function findImport(imports, dataset) {
+  const imported = imports.find((item) => item.dataset === dataset);
+  if (!imported) {
+    throw new Error(`Missing ${dataset} import.`);
+  }
+  return imported;
+}
+function createUnitId2(values) {
+  return [values.WOJ ?? "", values.POW ?? "", values.GMI ?? "", values.RODZ ?? values.RODZ_GMI ?? ""].join("-");
+}
+
+// src/features/sync-database/infrastructure/sqlite-database-builder.ts
+var SqliteDatabaseBuilder = class {
+  async build(sourceFiles) {
+    const SQL = await loadSqlJs();
+    const db = new SQL.Database();
+    try {
+      const imports = sourceFiles.map((sourceFile) => importTerytSourceFile(sourceFile));
+      validateTerytRelations(imports);
+      createSchema(db);
+      db.run("BEGIN");
+      insertRawDatasets(db, imports);
+      insertSearchTables(db, imports);
+      insertMetadata(db, imports);
+      db.run("COMMIT");
+      return {
+        content: db.export()
+      };
+    } catch (error) {
+      rollback(db);
+      throw error;
+    } finally {
+      db.close();
+    }
+  }
+};
+var sqlJs = null;
+function loadSqlJs() {
+  sqlJs ??= initSqlJs();
+  return sqlJs;
+}
+function createSchema(db) {
+  for (const statement of terytSqliteSchema) {
+    runSchemaStatement(db, statement);
+  }
+}
+function runSchemaStatement(db, statement) {
+  try {
+    db.run(statement);
+  } catch (error) {
+    const fallback = createFtsFallbackStatement(statement, error);
+    if (!fallback) {
+      throw error;
+    }
+    db.run(fallback);
+  }
+}
+function createFtsFallbackStatement(statement, error) {
+  if (!(error instanceof Error) || !error.message.includes("no such module: fts5")) {
+    return null;
+  }
+  const prefix = "CREATE VIRTUAL TABLE ";
+  if (!statement.startsWith(prefix)) {
+    return null;
+  }
+  const tableNameEnd = statement.indexOf(" USING fts5(");
+  if (tableNameEnd < prefix.length) {
+    return null;
+  }
+  const firstColumnStart = tableNameEnd + " USING fts5(".length;
+  const firstColumnEnd = statement.indexOf(",", firstColumnStart);
+  const tableName = statement.slice(prefix.length, tableNameEnd);
+  const firstColumn = statement.slice(firstColumnStart, firstColumnEnd < 0 ? void 0 : firstColumnEnd).trim();
+  return tableName && firstColumn ? `CREATE TABLE ${tableName} (${firstColumn} TEXT)` : null;
+}
+function insertRawDatasets(db, imports) {
+  for (const imported of imports) {
+    insertRows(db, `raw_${imported.dataset.toLowerCase()}`, imported.columns, imported.rows);
+  }
+}
+function insertMetadata(db, imports) {
+  const metadata = [
+    ["datasetCount", String(imports.length)],
+    ["stateDates", imports.map((item) => `${item.dataset}:${item.stateDate}`).join(",")]
+  ];
+  for (const [key, value] of metadata) {
+    db.run("INSERT INTO metadata (key, value) VALUES (?, ?)", [key, value]);
+  }
+}
+function insertRows(db, table, columns, rows) {
+  const columnList = columns.join(", ");
+  const placeholders = columns.map(() => "?").join(", ");
+  const statement = db.prepare(`INSERT INTO ${table} (${columnList}) VALUES (${placeholders})`);
+  try {
+    for (const row of rows) {
+      statement.run(columns.map((column) => row.values[column] ?? ""));
+    }
+  } finally {
+    statement.free();
+  }
+}
+function rollback(db) {
+  try {
+    db.run("ROLLBACK");
+  } catch {
+  }
+}
+
+// src/mcp/registry.ts
+import { createCapabilityRegistry } from "@mcp-craftman/core";
+
+// src/features/get-place/application/get-place.ts
+async function getPlace(input, dependencies) {
+  const id = input.id.trim();
+  if (!id) {
+    throw new Error("get_place requires id.");
+  }
+  const place = await dependencies.placeDetailsRepository.getPlace(id);
+  return {
+    place,
+    stateDate: place?.stateDate ?? null
+  };
+}
+
+// src/features/get-place/mcp/get-place.tool.ts
+import { defineTool as defineTool2 } from "@mcp-craftman/core";
+function createGetPlaceTool(dependencies) {
+  return defineTool2({
+    name: "get_place",
+    description: "Gets a TERYT place by identifier.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        id: {
+          type: "string"
+        }
+      },
+      required: ["id"]
+    },
+    outputSchema: {
+      type: "object",
+      properties: {
+        place: {
+          anyOf: [
+            {
+              type: "object",
+              properties: {
+                id: {
+                  type: "string"
+                },
+                name: {
+                  type: "string"
+                },
+                stateDate: {
+                  type: "string"
+                },
+                unitId: {
+                  type: "string"
+                }
+              },
+              required: ["id", "name", "stateDate", "unitId"]
+            },
+            {
+              type: "null"
+            }
+          ]
+        },
+        stateDate: {
+          anyOf: [
+            {
+              type: "string"
+            },
+            {
+              type: "null"
+            }
+          ]
+        }
+      },
+      required: ["place", "stateDate"]
+    },
+    policy: "read",
+    returnsStructuredContent: true,
+    annotations: {
+      readOnlyHint: true
+    },
+    handler: async (input) => ({
+      structuredContent: await getPlace(parseInput(input), dependencies)
+    })
+  });
+}
+function parseInput(input) {
+  if (typeof input !== "object" || input === null || !("id" in input) || typeof input.id !== "string") {
+    throw new Error("get_place requires id.");
+  }
+  return {
+    id: input.id
+  };
+}
+
+// src/features/get-street/application/get-street.ts
+async function getStreet(input, dependencies) {
+  const id = input.id.trim();
+  if (!id) {
+    throw new Error("get_street requires id.");
+  }
+  const street = await dependencies.streetDetailsRepository.getStreet(id);
+  return {
+    stateDate: street?.stateDate ?? null,
+    street
+  };
+}
+
+// src/features/get-street/mcp/get-street.tool.ts
+import { defineTool as defineTool3 } from "@mcp-craftman/core";
+function createGetStreetTool(dependencies) {
+  return defineTool3({
+    name: "get_street",
+    description: "Gets a TERYT street by identifier.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        id: {
+          type: "string"
+        }
+      },
+      required: ["id"]
+    },
+    outputSchema: {
+      type: "object",
+      properties: {
+        stateDate: {
+          anyOf: [
+            {
+              type: "string"
+            },
+            {
+              type: "null"
+            }
+          ]
+        },
+        street: {
+          anyOf: [
+            {
+              type: "object",
+              properties: {
+                code: {
+                  type: "string"
+                },
+                id: {
+                  type: "string"
+                },
+                name: {
+                  type: "string"
+                },
+                placeId: {
+                  type: "string"
+                },
+                stateDate: {
+                  type: "string"
+                }
+              },
+              required: ["code", "id", "name", "placeId", "stateDate"]
+            },
+            {
+              type: "null"
+            }
+          ]
+        }
+      },
+      required: ["stateDate", "street"]
+    },
+    policy: "read",
+    returnsStructuredContent: true,
+    annotations: {
+      readOnlyHint: true
+    },
+    handler: async (input) => ({
+      structuredContent: await getStreet(parseInput2(input), dependencies)
+    })
+  });
+}
+function parseInput2(input) {
+  if (typeof input !== "object" || input === null || !("id" in input) || typeof input.id !== "string") {
+    throw new Error("get_street requires id.");
+  }
+  return {
+    id: input.id
+  };
+}
+
+// src/features/get-unit/application/get-unit.ts
+async function getUnit(input, dependencies) {
+  const id = input.id.trim();
+  if (!id) {
+    throw new Error("get_unit requires id.");
+  }
+  const unit = await dependencies.unitDetailsRepository.getUnit(id);
+  return {
+    stateDate: unit?.stateDate ?? null,
+    unit
+  };
+}
+
+// src/features/get-unit/mcp/get-unit.tool.ts
+import { defineTool as defineTool4 } from "@mcp-craftman/core";
+function createGetUnitTool(dependencies) {
+  return defineTool4({
+    name: "get_unit",
+    description: "Gets a TERYT territorial unit by identifier.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        id: {
+          type: "string"
+        }
+      },
+      required: ["id"]
+    },
+    outputSchema: {
+      type: "object",
+      properties: {
+        stateDate: {
+          anyOf: [
+            {
+              type: "string"
+            },
+            {
+              type: "null"
+            }
+          ]
+        },
+        unit: {
+          anyOf: [
+            {
+              type: "object",
+              properties: {
+                id: {
+                  type: "string"
+                },
+                name: {
+                  type: "string"
+                },
+                stateDate: {
+                  type: "string"
+                },
+                type: {
+                  type: "string"
+                }
+              },
+              required: ["id", "name", "stateDate", "type"]
+            },
+            {
+              type: "null"
+            }
+          ]
+        }
+      },
+      required: ["stateDate", "unit"]
+    },
+    policy: "read",
+    returnsStructuredContent: true,
+    annotations: {
+      readOnlyHint: true
+    },
+    handler: async (input) => ({
+      structuredContent: await getUnit(parseInput3(input), dependencies)
+    })
+  });
+}
+function parseInput3(input) {
+  if (typeof input !== "object" || input === null || !("id" in input) || typeof input.id !== "string") {
+    throw new Error("get_unit requires id.");
+  }
+  return {
+    id: input.id
+  };
+}
+
+// src/features/health/application/get-health.ts
+function getHealth() {
+  return {
+    ok: true
+  };
+}
+
+// src/features/health/mcp/health.tool.ts
+import { defineTool as defineTool5 } from "@mcp-craftman/core";
+var healthTool = defineTool5({
+  name: "health_status",
+  description: "Returns basic server health.",
+  policy: "read",
+  returnsStructuredContent: true,
+  outputSchema: {
+    type: "object",
+    properties: {
+      ok: {
+        type: "boolean"
+      }
+    },
+    required: ["ok"]
+  },
+  annotations: {
+    readOnlyHint: true
+  },
+  handler: () => ({
+    structuredContent: getHealth()
+  })
+});
+
+// src/features/resolve-address/application/resolve-address.ts
+var DEFAULT_LIMIT = 20;
+var MAX_LIMIT = 100;
+async function resolveAddress(input, dependencies) {
+  const limit = normalizeLimit(input.limit);
+  const query = input.query.trim();
+  if (!query) {
+    return {
+      addresses: [],
+      stateDate: null
+    };
+  }
+  const normalizedQuery = normalizeName(query);
+  const addresses = await dependencies.addressRepository.listAddresses();
+  const matches = addresses.flatMap((address) => {
+    if (address.id === query) {
+      return [
+        {
+          address,
+          confidence: 1,
+          matchedBy: "exact_code"
+        }
+      ];
+    }
+    const normalizedAddress = normalizeName(formatAddress(address));
+    if (normalizedAddress === normalizedQuery) {
+      return [
+        {
+          address,
+          confidence: 0.95,
+          matchedBy: "exact_normalized_address"
+        }
+      ];
+    }
+    if (normalizedAddress.startsWith(normalizedQuery)) {
+      return [
+        {
+          address,
+          confidence: 0.75,
+          matchedBy: "prefix"
+        }
+      ];
+    }
+    return [];
+  }).sort(
+    (left, right) => right.confidence - left.confidence || formatAddress(left.address).localeCompare(formatAddress(right.address))
+  ).slice(0, limit);
+  return {
+    addresses: matches,
+    stateDate: matches[0]?.address.stateDate ?? null
+  };
+}
+function formatAddress(address) {
+  return [address.place.name, address.street?.name].filter(Boolean).join(" ");
+}
+function normalizeLimit(limit) {
+  if (limit === void 0) {
+    return DEFAULT_LIMIT;
+  }
+  if (!Number.isInteger(limit) || limit < 1) {
+    throw new Error("resolve_address limit must be a positive integer.");
+  }
+  return Math.min(limit, MAX_LIMIT);
+}
+function normalizeName(value) {
+  return value.replaceAll("\u0142", "l").replaceAll("\u0141", "L").normalize("NFKD").replaceAll(/\p{Diacritic}/gu, "").toLocaleLowerCase("pl-PL");
+}
+
+// src/features/resolve-address/mcp/resolve-address.tool.ts
+import { defineTool as defineTool6 } from "@mcp-craftman/core";
+function createResolveAddressTool(dependencies) {
+  return defineTool6({
+    inputSchema,
+    outputSchema,
+    name: "resolve_address",
+    description: "Resolves a TERYT address candidate to territorial, place, and street identifiers.",
+    policy: "read",
+    returnsStructuredContent: true,
+    annotations: {
+      readOnlyHint: true
+    },
+    handler: async (input) => ({
+      structuredContent: await resolveAddress(parseInput4(input), dependencies)
+    })
+  });
+}
+var inputSchema = {
+  type: "object",
+  properties: {
+    query: {
+      type: "string"
+    },
+    limit: {
+      type: "number",
+      default: 20,
+      maximum: 100,
+      minimum: 1
+    }
+  },
+  required: ["query"]
+};
+var outputSchema = {
+  type: "object",
+  properties: {
+    addresses: {
+      type: "array",
+      items: {
+        type: "object",
+        properties: {
+          address: {
+            type: "object",
+            properties: {
+              id: {
+                type: "string"
+              },
+              place: {
+                type: "object",
+                properties: {
+                  id: {
+                    type: "string"
+                  },
+                  name: {
+                    type: "string"
+                  }
+                },
+                required: ["id", "name"]
+              },
+              stateDate: {
+                type: "string"
+              },
+              street: {
+                anyOf: [
+                  {
+                    type: "object",
+                    properties: {
+                      code: {
+                        type: "string"
+                      },
+                      id: {
+                        type: "string"
+                      },
+                      name: {
+                        type: "string"
+                      }
+                    },
+                    required: ["code", "id", "name"]
+                  },
+                  {
+                    type: "null"
+                  }
+                ]
+              },
+              unit: {
+                type: "object",
+                properties: {
+                  id: {
+                    type: "string"
+                  },
+                  name: {
+                    type: "string"
+                  },
+                  type: {
+                    type: "string"
+                  }
+                },
+                required: ["id", "name", "type"]
+              }
+            },
+            required: ["id", "place", "stateDate", "street", "unit"]
+          },
+          confidence: {
+            type: "number"
+          },
+          matchedBy: {
+            type: "string",
+            enum: ["exact_code", "exact_normalized_address", "prefix"]
+          }
+        },
+        required: ["address", "confidence", "matchedBy"]
+      }
+    },
+    stateDate: {
+      anyOf: [
+        {
+          type: "string"
+        },
+        {
+          type: "null"
+        }
+      ]
+    }
+  },
+  required: ["addresses", "stateDate"]
+};
+function parseInput4(input) {
+  if (typeof input !== "object" || input === null || !("query" in input) || typeof input.query !== "string") {
+    throw new Error("resolve_address requires query.");
+  }
+  const limit = "limit" in input ? input.limit : void 0;
+  if (limit !== void 0 && typeof limit !== "number") {
+    throw new Error("resolve_address limit must be a number.");
+  }
+  return {
+    limit,
+    query: input.query
+  };
+}
+
+// src/features/search-places/application/search-places.ts
+var DEFAULT_LIMIT2 = 20;
+var MAX_LIMIT2 = 100;
+async function searchPlaces(input, dependencies) {
+  const limit = normalizeLimit2(input.limit);
+  const query = input.query.trim();
+  if (!query) {
+    return {
+      places: [],
+      stateDate: null
+    };
+  }
+  const normalizedQuery = normalizeName2(query);
+  const places = await dependencies.placeRepository.listPlaces();
+  const matches = places.flatMap((place) => {
+    if (place.id === query) {
+      return [
+        {
+          confidence: 1,
+          matchedBy: "exact_code",
+          place
+        }
+      ];
+    }
+    const normalizedName = normalizeName2(place.name);
+    if (normalizedName === normalizedQuery) {
+      return [
+        {
+          confidence: 0.95,
+          matchedBy: "exact_normalized_name",
+          place
+        }
+      ];
+    }
+    if (normalizedName.startsWith(normalizedQuery)) {
+      return [
+        {
+          confidence: 0.75,
+          matchedBy: "prefix",
+          place
+        }
+      ];
+    }
+    if (normalizedName.includes(normalizedQuery)) {
+      return [
+        {
+          confidence: 0.55,
+          matchedBy: "fts",
+          place
+        }
+      ];
+    }
+    return [];
+  }).sort((left, right) => right.confidence - left.confidence || left.place.name.localeCompare(right.place.name)).slice(0, limit);
+  return {
+    places: matches,
+    stateDate: matches[0]?.place.stateDate ?? null
+  };
+}
+function normalizeLimit2(limit) {
+  if (limit === void 0) {
+    return DEFAULT_LIMIT2;
+  }
+  if (!Number.isInteger(limit) || limit < 1) {
+    throw new Error("search_places limit must be a positive integer.");
+  }
+  return Math.min(limit, MAX_LIMIT2);
+}
+function normalizeName2(value) {
+  return value.replaceAll("\u0142", "l").replaceAll("\u0141", "L").normalize("NFKD").replaceAll(/\p{Diacritic}/gu, "").toLocaleLowerCase("pl-PL");
+}
+
+// src/features/search-places/mcp/search-places.tool.ts
+import { defineTool as defineTool7 } from "@mcp-craftman/core";
+function createSearchPlacesTool(dependencies) {
+  return defineTool7({
+    name: "search_places",
+    description: "Searches TERYT places.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: {
+          type: "string"
+        },
+        limit: {
+          type: "number",
+          default: 20,
+          maximum: 100,
+          minimum: 1
+        }
+      },
+      required: ["query"]
+    },
+    outputSchema: {
+      type: "object",
+      properties: {
+        places: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              confidence: {
+                type: "number"
+              },
+              matchedBy: {
+                type: "string",
+                enum: ["exact_code", "exact_normalized_name", "prefix", "fts"]
+              },
+              place: {
+                type: "object",
+                properties: {
+                  id: {
+                    type: "string"
+                  },
+                  name: {
+                    type: "string"
+                  },
+                  stateDate: {
+                    type: "string"
+                  },
+                  unitId: {
+                    type: "string"
+                  }
+                },
+                required: ["id", "name", "stateDate", "unitId"]
+              }
+            },
+            required: ["confidence", "matchedBy", "place"]
+          }
+        },
+        stateDate: {
+          anyOf: [
+            {
+              type: "string"
+            },
+            {
+              type: "null"
+            }
+          ]
+        }
+      },
+      required: ["places", "stateDate"]
+    },
+    policy: "read",
+    returnsStructuredContent: true,
+    annotations: {
+      readOnlyHint: true
+    },
+    handler: async (input) => ({
+      structuredContent: await searchPlaces(parseInput5(input), dependencies)
+    })
+  });
+}
+function parseInput5(input) {
+  if (typeof input !== "object" || input === null || !("query" in input) || typeof input.query !== "string") {
+    throw new Error("search_places requires query.");
+  }
+  const limit = "limit" in input ? input.limit : void 0;
+  if (limit !== void 0 && typeof limit !== "number") {
+    throw new Error("search_places limit must be a number.");
+  }
+  return {
+    limit,
+    query: input.query
+  };
+}
+
+// src/features/search-streets/application/search-streets.ts
+var DEFAULT_LIMIT3 = 20;
+var MAX_LIMIT3 = 100;
+async function searchStreets(input, dependencies) {
+  const limit = normalizeLimit3(input.limit);
+  const query = input.query.trim();
+  if (!query) {
+    return {
+      stateDate: null,
+      streets: []
+    };
+  }
+  const normalizedQuery = normalizeName3(query);
+  const streets = await dependencies.streetRepository.listStreets();
+  const matches = streets.flatMap((street) => {
+    if (street.id === query || street.code === query) {
+      return [
+        {
+          confidence: 1,
+          matchedBy: "exact_code",
+          street
+        }
+      ];
+    }
+    const normalizedName = normalizeName3(street.name);
+    if (normalizedName === normalizedQuery) {
+      return [
+        {
+          confidence: 0.95,
+          matchedBy: "exact_normalized_name",
+          street
+        }
+      ];
+    }
+    if (normalizedName.startsWith(normalizedQuery)) {
+      return [
+        {
+          confidence: 0.75,
+          matchedBy: "prefix",
+          street
+        }
+      ];
+    }
+    if (normalizedName.includes(normalizedQuery)) {
+      return [
+        {
+          confidence: 0.55,
+          matchedBy: "fts",
+          street
+        }
+      ];
+    }
+    return [];
+  }).sort((left, right) => right.confidence - left.confidence || left.street.name.localeCompare(right.street.name)).slice(0, limit);
+  return {
+    stateDate: matches[0]?.street.stateDate ?? null,
+    streets: matches
+  };
+}
+function normalizeLimit3(limit) {
+  if (limit === void 0) {
+    return DEFAULT_LIMIT3;
+  }
+  if (!Number.isInteger(limit) || limit < 1) {
+    throw new Error("search_streets limit must be a positive integer.");
+  }
+  return Math.min(limit, MAX_LIMIT3);
+}
+function normalizeName3(value) {
+  return value.replaceAll("\u0142", "l").replaceAll("\u0141", "L").normalize("NFKD").replaceAll(/\p{Diacritic}/gu, "").toLocaleLowerCase("pl-PL");
+}
+
+// src/features/search-streets/mcp/search-streets.tool.ts
+import { defineTool as defineTool8 } from "@mcp-craftman/core";
+function createSearchStreetsTool(dependencies) {
+  return defineTool8({
+    inputSchema: inputSchema2,
+    outputSchema: outputSchema2,
+    name: "search_streets",
+    description: "Searches TERYT streets.",
+    policy: "read",
+    returnsStructuredContent: true,
+    annotations: {
+      readOnlyHint: true
+    },
+    handler: async (input) => ({
+      structuredContent: await searchStreets(parseInput6(input), dependencies)
+    })
+  });
+}
+var inputSchema2 = {
+  type: "object",
+  properties: {
+    query: {
+      type: "string"
+    },
+    limit: {
+      type: "number",
+      default: 20,
+      maximum: 100,
+      minimum: 1
+    }
+  },
+  required: ["query"]
+};
+var outputSchema2 = {
+  type: "object",
+  properties: {
+    stateDate: {
+      anyOf: [
+        {
+          type: "string"
+        },
+        {
+          type: "null"
+        }
+      ]
+    },
+    streets: {
+      type: "array",
+      items: {
+        type: "object",
+        properties: {
+          confidence: {
+            type: "number"
+          },
+          matchedBy: {
+            type: "string",
+            enum: ["exact_code", "exact_normalized_name", "prefix", "fts"]
+          },
+          street: {
+            type: "object",
+            properties: {
+              code: {
+                type: "string"
+              },
+              id: {
+                type: "string"
+              },
+              name: {
+                type: "string"
+              },
+              placeId: {
+                type: "string"
+              },
+              stateDate: {
+                type: "string"
+              }
+            },
+            required: ["code", "id", "name", "placeId", "stateDate"]
+          }
+        },
+        required: ["confidence", "matchedBy", "street"]
+      }
+    }
+  },
+  required: ["stateDate", "streets"]
+};
+function parseInput6(input) {
+  if (typeof input !== "object" || input === null || !("query" in input) || typeof input.query !== "string") {
+    throw new Error("search_streets requires query.");
+  }
+  const limit = "limit" in input ? input.limit : void 0;
+  if (limit !== void 0 && typeof limit !== "number") {
+    throw new Error("search_streets limit must be a number.");
+  }
+  return {
+    limit,
+    query: input.query
+  };
+}
+
+// src/features/search-units/application/search-units.ts
+var DEFAULT_LIMIT4 = 20;
+var MAX_LIMIT4 = 100;
+async function searchUnits(input, dependencies) {
+  const query = input.query.trim();
+  const limit = normalizeLimit4(input.limit);
+  if (!query) {
+    return {
+      stateDate: null,
+      units: []
+    };
+  }
+  const normalizedQuery = normalizeName4(query);
+  const units = await dependencies.unitRepository.listUnits();
+  const matches = units.flatMap((unit) => {
+    if (unit.id === query) {
+      return [
+        {
+          confidence: 1,
+          matchedBy: "exact_code",
+          unit
+        }
+      ];
+    }
+    const normalizedName = normalizeName4(unit.name);
+    if (normalizedName === normalizedQuery) {
+      return [
+        {
+          confidence: 0.95,
+          matchedBy: "exact_normalized_name",
+          unit
+        }
+      ];
+    }
+    if (normalizedName.startsWith(normalizedQuery)) {
+      return [
+        {
+          confidence: 0.75,
+          matchedBy: "prefix",
+          unit
+        }
+      ];
+    }
+    if (normalizedName.includes(normalizedQuery)) {
+      return [
+        {
+          confidence: 0.55,
+          matchedBy: "fts",
+          unit
+        }
+      ];
+    }
+    return [];
+  }).sort((left, right) => right.confidence - left.confidence || left.unit.name.localeCompare(right.unit.name)).slice(0, limit);
+  return {
+    stateDate: matches[0]?.unit.stateDate ?? null,
+    units: matches
+  };
+}
+function normalizeLimit4(limit) {
+  if (limit === void 0) {
+    return DEFAULT_LIMIT4;
+  }
+  if (!Number.isInteger(limit) || limit < 1) {
+    throw new Error("search_units limit must be a positive integer.");
+  }
+  return Math.min(limit, MAX_LIMIT4);
+}
+function normalizeName4(value) {
+  return value.replaceAll("\u0142", "l").replaceAll("\u0141", "L").normalize("NFKD").replaceAll(/\p{Diacritic}/gu, "").toLocaleLowerCase("pl-PL");
+}
+
+// src/features/search-units/mcp/search-units.tool.ts
+import { defineTool as defineTool9 } from "@mcp-craftman/core";
+function createSearchUnitsTool(dependencies) {
+  return defineTool9({
+    name: "search_units",
+    description: "Searches TERYT territorial units.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: {
+          type: "string"
+        },
+        limit: {
+          type: "number",
+          default: 20,
+          maximum: 100,
+          minimum: 1
+        }
+      },
+      required: ["query"]
+    },
+    outputSchema: {
+      type: "object",
+      properties: {
+        stateDate: {
+          anyOf: [
+            {
+              type: "string"
+            },
+            {
+              type: "null"
+            }
+          ]
+        },
+        units: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              confidence: {
+                type: "number"
+              },
+              matchedBy: {
+                type: "string",
+                enum: ["exact_code", "exact_normalized_name", "prefix", "fts"]
+              },
+              unit: {
+                type: "object",
+                properties: {
+                  id: {
+                    type: "string"
+                  },
+                  name: {
+                    type: "string"
+                  },
+                  stateDate: {
+                    type: "string"
+                  },
+                  type: {
+                    type: "string"
+                  }
+                },
+                required: ["id", "name", "stateDate", "type"]
+              }
+            },
+            required: ["confidence", "matchedBy", "unit"]
+          }
+        }
+      },
+      required: ["stateDate", "units"]
+    },
+    policy: "read",
+    returnsStructuredContent: true,
+    annotations: {
+      readOnlyHint: true
+    },
+    handler: async (input) => ({
+      structuredContent: await searchUnits(parseInput7(input), dependencies)
+    })
+  });
+}
+function parseInput7(input) {
+  if (typeof input !== "object" || input === null || !("query" in input) || typeof input.query !== "string") {
+    throw new Error("search_units requires query.");
+  }
+  const limit = "limit" in input ? input.limit : void 0;
+  if (limit !== void 0 && typeof limit !== "number") {
+    throw new Error("search_units limit must be a number.");
+  }
+  return {
+    limit,
+    query: input.query
+  };
+}
+
+// src/features/source-status/application/get-source-status.ts
+async function getSourceStatus(input) {
+  const datasets = await input.sourceCatalog.listDatasets();
+  const snapshots = await Promise.all(
+    datasets.map(async (dataset) => {
+      const snapshot = await input.manifestStore.getSnapshot(dataset.code) ?? null;
+      return {
+        dataset,
+        snapshot,
+        sha256: snapshot?.sha256 ?? null,
+        stateDate: snapshot?.stateDate ?? null
+      };
+    })
+  );
+  const lastSuccessfulSync = snapshots.map((item) => item.snapshot?.downloadedAt).filter((downloadedAt) => Boolean(downloadedAt)).sort().at(-1) ?? null;
+  return {
+    lastCheckedAt: null,
+    localDatabase: {
+      status: snapshots.some((item) => item.snapshot) ? "available" : "missing"
+    },
+    remoteSource: {
+      errors: [],
+      status: "unknown"
+    },
+    datasets: snapshots,
+    lastSuccessfulSync
+  };
+}
+
+// src/features/source-status/mcp/source-status.tool.ts
+import { defineTool as defineTool10 } from "@mcp-craftman/core";
+function createSourceStatusTool(input) {
+  return defineTool10({
+    outputSchema: outputSchema3,
+    name: "source_status",
+    description: "Returns official TERYT source dataset status.",
+    policy: "read",
+    returnsStructuredContent: true,
+    annotations: {
+      readOnlyHint: true
+    },
+    handler: async () => ({
+      structuredContent: await getSourceStatus(input)
+    })
+  });
+}
+var outputSchema3 = {
+  type: "object",
+  properties: {
+    datasets: {
+      type: "array",
+      items: {
+        type: "object",
+        properties: {
+          dataset: {
+            type: "object",
+            properties: {
+              code: {
+                type: "string",
+                enum: ["TERC", "SIMC", "ULIC", "WMRODZ"]
+              },
+              name: {
+                type: "string"
+              },
+              sourceUrl: {
+                type: "string"
+              }
+            },
+            required: ["code", "name", "sourceUrl"]
+          },
+          snapshot: {
+            anyOf: [
+              {
+                type: "object",
+                properties: {
+                  dataset: {
+                    type: "string",
+                    enum: ["TERC", "SIMC", "ULIC", "WMRODZ"]
+                  },
+                  version: {
+                    type: "string"
+                  },
+                  downloadedAt: {
+                    type: "string"
+                  },
+                  recordCount: {
+                    type: "number"
+                  },
+                  sha256: {
+                    type: "string"
+                  },
+                  sourceUrl: {
+                    type: "string"
+                  },
+                  stateDate: {
+                    type: "string"
+                  }
+                },
+                required: ["dataset", "downloadedAt", "sourceUrl"]
+              },
+              {
+                type: "null"
+              }
+            ]
+          },
+          sha256: {
+            anyOf: [
+              {
+                type: "string"
+              },
+              {
+                type: "null"
+              }
+            ]
+          },
+          stateDate: {
+            anyOf: [
+              {
+                type: "string"
+              },
+              {
+                type: "null"
+              }
+            ]
+          }
+        },
+        required: ["dataset", "sha256", "snapshot", "stateDate"]
+      }
+    },
+    lastCheckedAt: {
+      anyOf: [
+        {
+          type: "string"
+        },
+        {
+          type: "null"
+        }
+      ]
+    },
+    lastSuccessfulSync: {
+      anyOf: [
+        {
+          type: "string"
+        },
+        {
+          type: "null"
+        }
+      ]
+    },
+    localDatabase: {
+      type: "object",
+      properties: {
+        status: {
+          type: "string",
+          enum: ["missing", "available"]
+        }
+      },
+      required: ["status"]
+    },
+    remoteSource: {
+      type: "object",
+      properties: {
+        errors: {
+          type: "array",
+          items: {
+            type: "string"
+          }
+        },
+        status: {
+          type: "string",
+          enum: ["unknown", "available", "error"]
+        }
+      },
+      required: ["errors", "status"]
+    }
+  },
+  required: ["datasets", "lastCheckedAt", "lastSuccessfulSync", "localDatabase", "remoteSource"]
+};
+
+// src/features/sync-database/application/plan-sync.ts
+async function planSync(input) {
+  const databaseExists = await input.fileStore.databaseExists();
+  if (input.mode === "missing" && databaseExists) {
+    return {
+      action: "skip_existing",
+      reason: "database_exists"
+    };
+  }
+  return {
+    action: "build_database",
+    reason: input.mode
+  };
+}
+
+// src/features/sync-database/application/sync-database.ts
+import { createHash as createHash2 } from "crypto";
+
+// src/features/sync-database/domain/dataset.ts
+var datasetCodes = ["TERC", "SIMC", "ULIC", "WMRODZ"];
+
+// src/features/sync-database/application/sync-database.ts
+async function syncDatabase(input) {
+  return input.lockStore.withSyncLock(async () => {
+    const plan = await planSync({
+      fileStore: input.fileStore,
+      mode: input.mode
+    });
+    if (plan.action === "skip_existing") {
+      return {
+        databasePath: null,
+        datasets: [],
+        mode: input.mode,
+        status: "skipped"
+      };
+    }
+    const sourceFiles = await Promise.all(datasetCodes.map((dataset) => input.source.download(dataset)));
+    const imports = sourceFiles.map((sourceFile) => ({
+      imported: importTerytSourceFile(sourceFile),
+      sourceFile
+    }));
+    const database = await input.databaseBuilder.build(sourceFiles);
+    const databasePath = await input.fileStore.swapDatabase(database.content);
+    const datasets = imports.map(({ imported, sourceFile }) => ({
+      columns: imported.columns,
+      dataset: sourceFile.dataset,
+      downloadedAt: input.now().toISOString(),
+      publishedAtObserved: null,
+      recordCount: imported.recordCount,
+      sha256: sha256(sourceFile.content),
+      source: "official-teryt-download",
+      sourceUrl: sourceFile.sourceUrl,
+      stateDate: imported.stateDate,
+      variant: "full"
+    }));
+    const snapshot = {
+      datasets,
+      builtAt: input.now().toISOString(),
+      path: databasePath
+    };
+    await input.manifestStore.writeSnapshot(snapshot);
+    return {
+      databasePath,
+      datasets,
+      mode: input.mode,
+      status: "synced"
+    };
+  });
+}
+function sha256(content) {
+  return createHash2("sha256").update(content).digest("hex");
+}
+
+// src/features/sync-database/mcp/sync-database.tool.ts
+import { defineTool as defineTool11 } from "@mcp-craftman/core";
+function createSyncDatabaseTool(input) {
+  return defineTool11({
+    inputSchema: inputSchema3,
+    outputSchema: outputSchema4,
+    name: "sync_database",
+    description: "Synchronizes the local TERYT database.",
+    policy: "write",
+    returnsStructuredContent: true,
+    annotations: {
+      destructiveHint: false,
+      idempotentHint: false,
+      readOnlyHint: false
+    },
+    handler: async (toolInput) => ({
+      structuredContent: await syncDatabase({
+        ...input,
+        mode: parseMode(toolInput)
+      })
+    })
+  });
+}
+var inputSchema3 = {
+  type: "object",
+  properties: {
+    mode: {
+      type: "string",
+      enum: ["missing", "stale", "force"]
+    }
+  },
+  required: ["mode"]
+};
+var outputSchema4 = {
+  type: "object",
+  properties: {
+    databasePath: {
+      anyOf: [
+        {
+          type: "string"
+        },
+        {
+          type: "null"
+        }
+      ]
+    },
+    datasets: {
+      type: "array",
+      items: {
+        type: "object",
+        properties: {
+          columns: {
+            type: "array",
+            items: {
+              type: "string"
+            }
+          },
+          dataset: {
+            type: "string",
+            enum: ["TERC", "SIMC", "ULIC", "WMRODZ"]
+          },
+          downloadedAt: {
+            type: "string"
+          },
+          publishedAtObserved: {
+            anyOf: [
+              {
+                type: "string"
+              },
+              {
+                type: "null"
+              }
+            ]
+          },
+          recordCount: {
+            type: "number"
+          },
+          sha256: {
+            type: "string"
+          },
+          source: {
+            type: "string"
+          },
+          sourceUrl: {
+            type: "string"
+          },
+          stateDate: {
+            type: "string"
+          },
+          variant: {
+            type: "string",
+            enum: ["full"]
+          }
+        },
+        required: [
+          "columns",
+          "dataset",
+          "downloadedAt",
+          "publishedAtObserved",
+          "recordCount",
+          "sha256",
+          "source",
+          "sourceUrl",
+          "stateDate",
+          "variant"
+        ]
+      }
+    },
+    mode: {
+      type: "string",
+      enum: ["missing", "stale", "force"]
+    },
+    status: {
+      type: "string",
+      enum: ["skipped", "synced"]
+    }
+  },
+  required: ["databasePath", "datasets", "mode", "status"]
+};
+function parseMode(input) {
+  if (typeof input === "object" && input !== null && "mode" in input) {
+    const mode = input.mode;
+    if (mode === "missing" || mode === "stale" || mode === "force") {
+      return mode;
+    }
+  }
+  throw new Error("sync_database requires mode: missing | stale | force.");
+}
+
+// src/mcp/registry.ts
+function createRegistry(input) {
+  return createCapabilityRegistry([
+    healthTool,
+    createServerStatusTool({
+      dataDir: input.config.dataDir,
+      transport: input.config.transport
+    }),
+    createSourceStatusTool({
+      manifestStore: input.manifestStore,
+      sourceCatalog: input.sourceCatalog
+    }),
+    createGetPlaceTool({
+      placeDetailsRepository: input.placeDetailsRepository
+    }),
+    createGetStreetTool({
+      streetDetailsRepository: input.streetDetailsRepository
+    }),
+    createGetUnitTool({
+      unitDetailsRepository: input.unitDetailsRepository
+    }),
+    createResolveAddressTool({
+      addressRepository: input.addressRepository
+    }),
+    createSearchPlacesTool({
+      placeRepository: input.placeRepository
+    }),
+    createSearchStreetsTool({
+      streetRepository: input.streetRepository
+    }),
+    createSearchUnitsTool({
+      unitRepository: input.unitRepository
+    }),
+    createSyncDatabaseTool(input.sync)
+  ]);
+}
+
+// src/app.ts
+function createApp(config = loadRuntimeConfig(), overrides = {}) {
+  const sourceCatalog = new EterytSourceCatalog();
+  const manifestStore = new JsonManifestStore(config.dataDir);
+  const syncFileStore = new LocalFileStore(config.dataDir);
+  const syncLockStore = new FileLockStore(config.dataDir);
+  const syncManifestStore = new JsonSyncManifestStore(config.dataDir);
+  const syncSource = overrides.syncSource ?? new EterytSource();
+  return createMcpApp({
+    name: "teryt-mcp",
+    version: "0.1.0",
+    registry: createRegistry({
+      config,
+      manifestStore,
+      sourceCatalog,
+      addressRepository: new InMemoryAddressRepository(),
+      placeDetailsRepository: new InMemoryPlaceDetailsRepository(),
+      placeRepository: new InMemoryPlaceRepository(),
+      streetDetailsRepository: new InMemoryStreetDetailsRepository(),
+      streetRepository: new InMemoryStreetRepository(),
+      unitDetailsRepository: new InMemoryUnitDetailsRepository(),
+      unitRepository: new InMemoryUnitRepository(),
+      sync: {
+        databaseBuilder: new SqliteDatabaseBuilder(),
+        fileStore: syncFileStore,
+        lockStore: syncLockStore,
+        manifestStore: syncManifestStore,
+        now: () => /* @__PURE__ */ new Date(),
+        source: syncSource
+      }
+    })
+  });
+}
+
+// src/server/serve.ts
+import { loadRuntimeConfig as loadRuntimeConfig2 } from "@mcp-craftman/node";
+
+// src/server/transports/http.ts
+import { startHttpServer } from "@mcp-craftman/node";
+function startHttpTransport(app, options = {}) {
+  return startHttpServer(app, options);
+}
+
+// src/server/transports/stdio.ts
+import { startStdioServer } from "@mcp-craftman/node";
+function startStdioTransport(app, options = {}) {
+  return startStdioServer(app, options);
+}
+
+// src/server/serve.ts
+async function serve(config = loadRuntimeConfig2()) {
+  const app = createApp(config);
+  if (config.transport === "http") {
+    return startHttpTransport(app, {
+      port: config.port
+    });
+  }
+  return startStdioTransport(app);
+}
+
+export {
+  getServerStatus,
+  createApp,
+  serve
+};