nyrezone-mcp 0.1.0 → 0.2.0

package/CHANGELOG.md

@@ -1,12 +1,55 @@
 # Changelog
 
+## 0.2.0 - 2026-10-29 (unpublished)
+
+- Remove the prior FAR-times-lot-area-minus-gross-building-area calculation for
+  every parcel. Recorded MapPLUTO FAR, area and district facts remain available;
+  they do not establish parcel capacity, unused development rights or compliance.
+- Retain deprecated `unused_floor_area.estimate_sqft`, `allowed_floor_area_sqft`,
+  `governing_far` and `overbuilt` keys as null, with basis
+  `not determined from recorded parcel data` and explicit limitations. The tool
+  output schema now declares these keys null; consumers must accept null.
+- Remove calculated capacity and compliance inferences from lot prose, tool
+  descriptions, server instructions and package/registry descriptions.
+- Label the public map link `Public lot map`; preserve `full_report_url` as a
+  documented legacy field name that does not provide paid report data.
+- Identify district output as scraped NYRezone HTML summaries, without claiming
+  direct verification against the NYC Zoning Resolution.
+- Identify release labels and check stamps as site-reported, not independently
+  validated for each result; use unknown when the release stamp is missing or
+  unavailable. Align package, lockfile, runtime and registry manifest at 0.2.0.
+- Expand existing fixture and real stdio tests for the former 16,094 sq ft example,
+  the formerly flagged Empire State Building, false split flags with multiple
+  districts, unknown source labels, null compatibility and owner-field exclusion.
+- Update existing exact dependency pins to MCP server/client SDK 2.4.0 and Zod
+  4.6.7 to resolve native npm audit advisories affecting the previous pins.
+- Reuse the existing SDK, test suite and documentation; no new service, framework,
+  schedule or publishing-trust change.
+
+## 2026-10-28 — Documentation accuracy
+
+Clarify that the published 0.1.0 stdio package is separate from the hosted ChatGPT
+facts app. Recorded FAR fields, calculated screening outputs and district summaries
+parsed from NYRezone are distinguished from parcel-specific legal capacity. The
+README now documents the separate residential-estimate/highest-FAR flag behavior,
+the legacy `allowed_floor_area_sqft`/`sq ft allowed` wording, split-lot limits and
+the public map destination of the `Full report` link. No runtime, version or
+dependency changed; these disclosures do not certify capacity or all district rules.
+
+Verification: 39 existing fixture/stdio tests passed. Published npm JavaScript
+matches the fresh source build. Three public BBL examples matched selected city
+record fields, and the city records' 26v2 version matched the package's methodology
+label on October 28. These observations establish neither legal allowance nor
+exhaustive API/district correctness.
+
 ## 0.1.1 - planned
 
 - Optional packaging: MCPB bundle and Smithery listing (removed from 0.1.0 until they can be built, signed and checksummed for real).
 
 ## 0.1.0 - 2026-10-15
 
-Initial local build (not published).
+Initial build; version 0.1.0 was subsequently published to npm and the official MCP
+registry on October 16, 2026.
 
 - Tools: `lookup_lot`, `get_zoning_district`, `list_zoning_districts`.
 - Lot data from NYRezone `/api/pluto`; owner name/type and assessed values are dropped before any result is returned.

package/README.md

@@ -1,6 +1,12 @@
 # nyrezone-mcp
 
-Read-only [MCP](https://modelcontextprotocol.io) server that gives AI assistants NYC zoning facts from the public data on [NYRezone](https://nyrezone.com): which zoning district a tax lot is in, built vs. allowed FAR, lot and building area, an estimated unused floor area, and the rules for each zoning district.
+Read-only [MCP](https://modelcontextprotocol.io) server that gives AI assistants recorded NYC lot fields from public [NYRezone](https://nyrezone.com) pages and APIs: zoning districts, MapPLUTO FAR fields, lot and gross building area, and district summaries as published by NYRezone.
+
+The legacy stdio package is separate from NYRezone's hosted ChatGPT facts app.
+Version 0.2.0 removes the previous floor-area calculations. Recorded parcel data
+and scraped district summaries do not determine parcel-specific legal capacity,
+unused development rights or zoning compliance, or certify that every district
+rule is current.
 
 It exposes only data that is already public and unauthenticated. No owner names, no assessed values, no paid report data, no account access.
 
@@ -36,25 +42,57 @@ All tools are read-only (`readOnlyHint: true`).
 
 | Tool | Input | Returns |
 |---|---|---|
-| `lookup_lot` | `address` (starts with a house number, include the borough) **or** `bbl` (10-digit borough-block-lot) | Zoning district(s), overlays and special districts, built FAR vs. maximum FAR, lot area, building area, estimated unused floor area, year built, land use. Ambiguous or unknown input returns an error, never a guess. |
+| `lookup_lot` | `address` (starts with a house number, include the borough) **or** `bbl` (10-digit borough-block-lot) | Recorded zoning district(s), overlays, special districts and FAR fields, lot/gross building area, year built and land use. Deprecated capacity calculation fields are retained as null. Ambiguous or unknown address matches return an error. |
 | `get_zoning_district` | `code`, e.g. `R6A`, `C4-2`, `M1-2/R6A` | FAR, height rules and bonuses as NYRezone publishes them, citywide lot counts, average built FAR. Unknown code returns the list of valid codes. |
 | `list_zoning_districts` | optional `family`, e.g. `R6` | The 51 districts NYRezone documents, each with its district-family description. |
 
-Every result ends with a source line (MapPLUTO release as stated by NYRezone, the matching nyrezone.com page, and for lots a `Full report` link) and a disclaimer.
+Every successful result includes a source line and disclaimer. The MapPLUTO release
+label for lot lookups is reported by NYRezone's methodology page; district lookups
+use the label on the district page. Neither is independently validated for the
+returned parcel or result. A missing or unavailable release stamp is `unknown`. District rules are parsed from NYRezone's pages, not fetched directly
+from the Zoning Resolution. The visible `Public lot map` link and legacy `full_report_url` field both open
+the public lot map; neither returns paid report data.
 
 Not included: a borough-level "underbuilt" summary. NYRezone publishes that only as web pages, not as a data endpoint.
 
 ### Example
 
-`lookup_lot` with `bbl: "3052410015"` returns, in part: zoning R7A, lot area 4,675 sq ft, building area 2,606 sq ft, built FAR 0.56 against a 4.0 residential maximum, and an estimated 16,094 sq ft unused.
+`lookup_lot` with `bbl: "3052410015"` returns, in part: recorded zoning R7A,
+lot area 4,675 sq ft, gross building area 2,606 sq ft, built FAR 0.56 and a
+MapPLUTO residential FAR field of 4.0. It does not calculate capacity from those
+fields. Its `unused_floor_area` compatibility object includes:
+
+```json
+{
+  "estimate_sqft": null,
+  "allowed_floor_area_sqft": null,
+  "governing_far": null,
+  "overbuilt": null,
+  "basis": "not determined from recorded parcel data"
+}
+```
+
+The object also includes `caveats` describing the limits below.
+
+## Capacity is not determined
 
-## How the unused-floor-area estimate works
+The previous release multiplied recorded FAR by lot area and subtracted gross
+building area. Version 0.2.0 removes that arithmetic for every lot, including
+split-zoned lots and records with multiple districts but no split-zone flag.
+The four deprecated fields above remain present and always null; their output
+schema accepts null. Consumers that assumed a numeric estimate or boolean flag
+must handle null.
 
-`maximum FAR x lot area - existing building area`, using MapPLUTO's residential FAR (commercial or community-facility FAR if there is no residential FAR). It is a screening number only. It does not account for street width, special districts, overlays, split-zoned lots, mapped streets, or City of Yes / Universal Affordability Preference bonuses. If the building already exceeds the maximum, the tool reports 0 and says the lot is over-built.
+Gross building area is not zoning floor area. Recorded FAR fields alone do not
+establish applicable FAR or legally permitted floor area. District boundaries,
+split-zone geometry, applicable uses, special districts, overlays, bonuses,
+zoning-lot history and current rules require separate verification. The tool
+returns the recorded district and FAR facts without deciding capacity, unused
+development rights or compliance.
 
 ## Data sources and what leaves your machine
 
-- **nyrezone.com** (`/api/pluto`, `/zoning`, `/zoning/<code>`, `/methodology`): lot data and district pages. Data is NYC DCP MapPLUTO; the release is read from NYRezone's own methodology page.
+- **nyrezone.com** (`/api/pluto`, `/zoning`, `/zoning/<code>`, `/methodology`): lot data and district pages. The lot endpoint supplies MapPLUTO fields; HTML district summaries are NYRezone's presentation, not direct Zoning Resolution verification. Release labels and check stamps are reported by the site, not independently validated for each returned parcel.
 - **NYC Planning Labs Geosearch** (`geosearch.planninglabs.nyc`): used only to turn a street address into a BBL, because NYRezone has no address endpoint. This is the one third-party host; the address you ask about is sent to it. BBL lookups and district lookups never contact it.
 
 The owner name and owner type that NYRezone's lot API returns are dropped in this server and never appear in a tool result.

package/dist/client.d.ts

@@ -1,4 +1,4 @@
-export declare const VERSION = "0.1.0";
+export declare const VERSION = "0.2.0";
 export declare const REPO_URL = "https://github.com/gbrussich52/nyrezone-mcp";
 export type UpstreamKind = 'timeout' | 'http' | 'network' | 'rate_limited' | 'too_large' | 'parse';
 export declare class UpstreamError extends Error {

package/dist/client.js

@@ -1,7 +1,7 @@
 // HTTP access for the two public hosts this server reads. Everything that touches
 // the network goes through here so the politeness rules (User-Agent, cache,
 // serialized requests, request cap, timeout, size cap) live in one place.
-export const VERSION = '0.1.0';
+export const VERSION = '0.2.0';
 export const REPO_URL = 'https://github.com/gbrussich52/nyrezone-mcp';
 export class UpstreamError extends Error {
     kind;

package/dist/lot.d.ts

@@ -36,19 +36,13 @@ export interface LotRecord {
     unused_floor_area: UnusedFloorArea;
 }
 export interface UnusedFloorArea {
-    /** Estimated unused floor area in sq ft, or null when the inputs are missing. */
-    estimate_sqft: number | null;
-    /** True when existing building area already exceeds the FAR-based maximum. */
-    overbuilt: boolean;
-    allowed_floor_area_sqft: number | null;
-    governing_far: number | null;
+    /** Deprecated compatibility fields: recorded parcel data does not determine capacity. */
+    estimate_sqft: null;
+    overbuilt: null;
+    allowed_floor_area_sqft: null;
+    governing_far: null;
     basis: string;
     caveats: string[];
 }
-export declare function computeUnusedFloorArea(lotArea: number | null, buildingArea: number | null, far: {
-    residential: number | null;
-    commercial: number | null;
-    community_facility: number | null;
-}, splitZone: boolean): UnusedFloorArea;
 /** Allow-list mapping from the raw API row. Throws InputError-free; callers validate the BBL first. */
 export declare function mapPlutoRow(raw: unknown, bbl: string): LotRecord;

package/dist/lot.js

@@ -60,55 +60,19 @@ function str(v) {
     return s === '' ? null : s;
 }
 const round = (n, places) => Math.round(n * 10 ** places) / 10 ** places;
-export function computeUnusedFloorArea(lotArea, buildingArea, far, splitZone) {
-    const caveats = [
-        'Simple MapPLUTO-based estimate: maximum FAR x lot area minus existing building area.',
-        'Building area is MapPLUTO gross area, which is larger than zoning floor area.',
-        'Ignores street width, special districts, overlays, lot splits, mapped streets, and City of Yes / Universal Affordability Preference bonuses, which can change the true maximum.',
-    ];
-    if (splitZone)
-        caveats.push('This lot spans more than one zoning district; MapPLUTO reports a single set of FAR values, so the estimate may be off.');
-    // Highest listed FAR governs: a commercial or community-facility FAR can exceed residential
-    // (e.g. C5-3 lists residential 10 but commercial 15), and using residential alone would
-    // wrongly flag such lots as overbuilt.
-    const candidates = [
-        ['residential', far.residential ?? 0],
-        ['commercial', far.commercial ?? 0],
-        ['community-facility', far.community_facility ?? 0],
-    ];
-    const top = Math.max(...candidates.map(([, v]) => v));
-    let governing = null;
-    let basis;
-    if (top > 0) {
-        governing = top;
-        const names = candidates.filter(([, v]) => v === top).map(([n]) => n).join(' / ');
-        basis = `Highest FAR MapPLUTO lists is ${top} (${names}).`;
-    }
-    else {
-        basis = 'MapPLUTO lists no maximum FAR for this lot, so no estimate is possible.';
-    }
-    if (governing === null || lotArea === null || lotArea <= 0 || buildingArea === null) {
-        if (governing !== null)
-            basis += ' Lot area or building area is missing, so no estimate is possible.';
-        return { estimate_sqft: null, overbuilt: false, allowed_floor_area_sqft: null, governing_far: governing, basis, caveats };
-    }
-    // Headline estimate uses residential FAR when listed (matches NYRezone's methodology); the
-    // overbuilt flag uses the highest FAR so community-facility or commercial uses never make a
-    // lot look non-compliant. Community-facility FAR alone must not inflate a residential lot's headroom.
-    const resid = far.residential ?? 0;
-    const estFar = resid > 0 ? resid : governing;
-    if (resid > 0 && resid < governing) {
-        basis = `Estimate uses residential FAR ${resid}; MapPLUTO also lists up to ${governing} for other uses (commercial / community-facility).`;
-    }
-    const allowed = estFar * lotArea;
-    const overbuilt = buildingArea > governing * lotArea;
+function undeterminedFloorArea() {
     return {
-        estimate_sqft: Math.max(0, Math.round(allowed - buildingArea)),
-        overbuilt,
-        allowed_floor_area_sqft: overbuilt ? Math.round(governing * lotArea) : Math.round(allowed),
-        governing_far: overbuilt ? governing : estFar,
-        basis,
-        caveats,
+        estimate_sqft: null,
+        overbuilt: null,
+        allowed_floor_area_sqft: null,
+        governing_far: null,
+        basis: 'not determined from recorded parcel data',
+        caveats: [
+            'MapPLUTO building area is gross building area, not zoning floor area.',
+            'Recorded FAR fields do not establish an applicable FAR or legally permitted floor area for this parcel.',
+            'District boundaries and split-zone geometry, applicable uses, special districts, overlays, bonuses, zoning-lot history and current rules require separate verification.',
+            'Unused development rights, development capacity and zoning compliance are not determined by this tool.',
+        ],
     };
 }
 /** Allow-list mapping from the raw API row. Throws InputError-free; callers validate the BBL first. */
@@ -160,6 +124,6 @@ export function mapPlutoRow(raw, bbl) {
         year_built: yearBuilt && yearBuilt > 0 ? yearBuilt : null,
         built_far: builtFar === null ? null : round(builtFar, 2),
         max_far: farRounded,
-        unused_floor_area: computeUnusedFloorArea(lotArea, buildingArea, far, splitZone),
+        unused_floor_area: undeterminedFloorArea(),
     };
 }

package/dist/server.js

@@ -4,9 +4,9 @@ import { HttpClient, VERSION } from './client.js';
 import { getDistrict, listDistricts, lookupLot } from './service.js';
 const INSTRUCTIONS = [
     'Read-only access to public NYC zoning data via NYRezone (nyrezone.com), which is built on NYC MapPLUTO.',
-    'Tools: lookup_lot (a tax lot by address or 10-digit BBL), get_zoning_district (rules for one zoning code), list_zoning_districts.',
+    'Tools: lookup_lot (a tax lot by address or 10-digit BBL), get_zoning_district (NYRezone HTML summary for one zoning code), list_zoning_districts.',
     'Report only what the tools return and always keep the source line and disclaimer with it.',
-    'Unused floor area is a simplified FAR-based estimate, not a legal buildable-area determination; say so.',
+    'Recorded FAR and gross building area do not determine development capacity, unused development rights or zoning compliance. Deprecated unused_floor_area calculation fields are always null.',
     'If a tool reports an ambiguous or unknown input, ask the user to clarify rather than guessing.',
 ].join(' ');
 // openWorldHint is true because every call reaches out to public web services.
@@ -39,10 +39,10 @@ const lotSchema = z.object({
     built_far: z.number().nullable(),
     max_far: z.object({ residential: z.number().nullable(), commercial: z.number().nullable(), community_facility: z.number().nullable() }),
     unused_floor_area: z.object({
-        estimate_sqft: z.number().nullable(),
-        overbuilt: z.boolean(),
-        allowed_floor_area_sqft: z.number().nullable(),
-        governing_far: z.number().nullable(),
+        estimate_sqft: z.null().describe('Deprecated; capacity is not determined from recorded parcel data.'),
+        overbuilt: z.null().describe('Deprecated; zoning compliance is not determined from gross building area.'),
+        allowed_floor_area_sqft: z.null().describe('Deprecated; legally permitted floor area is not determined.'),
+        governing_far: z.null().describe('Deprecated; applicable FAR is not determined.'),
         basis: z.string(),
         caveats: z.array(z.string()),
     }),
@@ -52,7 +52,7 @@ export function createServer(clientOptions = {}) {
     const server = new McpServer({ name: 'nyrezone-mcp', version: VERSION, title: 'NYRezone - NYC zoning lookups' }, { capabilities: { tools: {} }, instructions: INSTRUCTIONS });
     server.registerTool('lookup_lot', {
         title: 'Look up an NYC tax lot',
-        description: 'Look up one NYC tax lot by street address OR 10-digit BBL (borough-block-lot). Returns zoning district(s), built vs. allowed FAR, lot and building area, an estimated unused floor area, year built and land use, from MapPLUTO via NYRezone. Provide exactly one of address or bbl. Addresses must start with a house number and should include the borough; an ambiguous or unknown address returns an error instead of a guess. Owner and assessment data are never returned.',
+        description: 'Look up one NYC tax lot by street address OR 10-digit BBL (borough-block-lot). Returns recorded zoning district(s), MapPLUTO FAR fields, lot and gross building area, year built and land use via NYRezone. Does not determine development capacity, unused development rights, applicable FAR or zoning compliance; deprecated calculation fields are null. Provide exactly one of address or bbl. Addresses must start with a house number and should include the borough; an ambiguous or unknown address returns an error instead of a guess. Owner and assessment data are never returned.',
         inputSchema: z.object({
             address: z.string().optional().describe('Street address starting with a house number, e.g. "1187 Ocean Ave, Brooklyn".'),
             bbl: z.string().optional().describe('10-digit BBL, e.g. 3052410015 (1 Manhattan, 2 Bronx, 3 Brooklyn, 4 Queens, 5 Staten Island).'),
@@ -61,7 +61,7 @@ export function createServer(clientOptions = {}) {
             lot: lotSchema,
             resolved_from: z.enum(['bbl', 'address']),
             matched_address: z.string().nullable(),
-            full_report_url: z.string(),
+            full_report_url: z.string().describe('Legacy field name: public lot map URL; no paid report data'),
             district_pages: z.array(z.string()),
             source: z.string(),
         }),
@@ -69,7 +69,7 @@ export function createServer(clientOptions = {}) {
     }, async (args) => respond(await lookupLot(client, args)));
     server.registerTool('get_zoning_district', {
         title: 'Get an NYC zoning district',
-        description: 'Get the rules NYRezone publishes for one NYC zoning district code (e.g. R6A, C4-2, M1-2/R6A): max FAR, base and maximum height, bonuses, citywide lot counts and average built FAR. Height/setback detail is only what NYRezone publishes for that district. An unknown code returns the list of valid codes.',
+        description: 'Get the HTML district summary NYRezone publishes for one NYC zoning district code (e.g. R6A, C4-2, M1-2/R6A): max FAR, base and maximum height, bonuses, citywide lot counts and average built FAR. Values are scraped NYRezone summaries, not independently verified against the Zoning Resolution or applied to a parcel. An unknown code returns the list of valid codes.',
         inputSchema: z.object({ code: z.string().describe('Zoning district code such as R6A, R7-2, C4-2 or M1-2/R6A (case-insensitive).') }),
         outputSchema: z.object({
             code: z.string(),

package/dist/service.js

@@ -5,7 +5,9 @@ import { AddressNotFoundError, AmbiguousAddressError, resolveAddress } from './g
 import { InputError, mapPlutoRow, parseBbl } from './lot.js';
 import { ParseError, parseDistrictPage, parseVintage, parseZoningIndex } from './parse.js';
 export const DISCLAIMER = 'Informational only; not legal, architectural, or zoning-compliance advice. Confirm with NYC Department of City Planning / a licensed professional before relying on it.';
-const FALLBACK_VINTAGE = 'NYC MapPLUTO (release as stated at https://nyrezone.com/methodology)';
+function reportedVintage(release, checkedOn) {
+    return `MapPLUTO release reported by NYRezone: ${release ?? 'unknown'}${checkedOn ? ` (site check stamp: ${checkedOn})` : ''}; not independently validated for this result`;
+}
 const fail = (error) => ({ ok: false, error });
 function upstreamMessage(err) {
     if (err instanceof UpstreamError) {
@@ -29,14 +31,13 @@ async function vintage(client) {
         const res = await client.getText(`${client.nyrezoneBase}/methodology`, 'text/html');
         if (res.status === 200) {
             const v = parseVintage(res.body);
-            if (v.release)
-                return v.checkedOn ? `NYC ${v.release} (checked ${v.checkedOn})` : `NYC ${v.release}`;
+            return reportedVintage(v.release, v.checkedOn);
         }
     }
     catch {
-        // The vintage line is a nicety; never fail a lookup over it.
+        // Preserve the lookup, but explicitly report an unknown release when the source is unavailable.
     }
-    return FALLBACK_VINTAGE;
+    return reportedVintage(null, null);
 }
 const districtUrl = (client, slug) => `${client.nyrezoneBase}/zoning/${slug}`;
 // ---------- districts ----------
@@ -90,10 +91,10 @@ export async function getDistrict(client, rawCode) {
             return fail(`NYRezone has no page for ${entry.code} right now.`);
         const page = parseDistrictPage(res.body);
         const rulesNote = page.rules.length === 0
-            ? 'NYRezone publishes parcel statistics but no verified bulk/height/setback rules for this district; consult the Zoning Resolution.'
+            ? 'NYRezone publishes parcel statistics but no bulk/height/setback rules table for this district; consult the Zoning Resolution.'
             : null;
-        const vint = page.dataVintage ? `NYC ${page.dataVintage}${page.dataCheckedOn ? ` (checked ${page.dataCheckedOn})` : ''}` : FALLBACK_VINTAGE;
-        const source = `Source: ${vint} via NYRezone; rule values from the NYC Zoning Resolution as shown on ${url}. ${DISCLAIMER}`;
+        const vint = reportedVintage(page.dataVintage, page.dataCheckedOn);
+        const source = `Source: NYRezone HTML district summary, ${url}. ${vint}. Rule values are as published by NYRezone, not independently verified against the NYC Zoning Resolution. ${DISCLAIMER}`;
         const out = [`${page.code} - ${page.summary}`, ''];
         if (page.rules.length) {
             out.push('Rules (as published by NYRezone):');
@@ -174,7 +175,7 @@ export async function lookupLot(client, q) {
         }
         const slugs = lot.zoning_districts.map((z) => z.toLowerCase().replace(/\//g, '-')).filter((s) => known === null || known.has(s));
         const pages = slugs.map((s) => districtUrl(client, s));
-        const source = `Source: ${vint} via ${client.nyrezoneBase}. District pages: ${pages.join(', ') || 'n/a'}. Full report: ${reportUrl}. ${DISCLAIMER}`;
+        const source = `Source: NYRezone /api/pluto parcel records via ${client.nyrezoneBase}. ${vint}. District pages: ${pages.join(', ') || 'n/a'}. Public lot map: ${reportUrl}. ${DISCLAIMER}`;
         const u = lot.unused_floor_area;
         const lines = [
             `BBL ${lot.bbl}${lot.address ? ` - ${lot.address}` : ''}${lot.borough ? `, ${lot.borough}` : ''}${lot.zip ? ` ${lot.zip}` : ''}`,
@@ -183,12 +184,8 @@ export async function lookupLot(client, q) {
             lot.historic_district || lot.landmark ? `Historic: ${[lot.historic_district, lot.landmark].filter(Boolean).join('; ')}` : '',
             `Land use: ${lot.land_use ? `${lot.land_use.code} ${lot.land_use.label}` : 'unknown'}${lot.building_class ? `; building class ${lot.building_class}` : ''}`,
             `Lot area: ${fmt(lot.lot_area_sqft, ' sq ft')}; building area: ${fmt(lot.building_area_sqft, ' sq ft')}; floors: ${fmt(lot.num_floors)}; year built: ${lot.year_built ?? 'unknown'}; residential units: ${fmt(lot.residential_units)}`,
-            `FAR - built: ${fmt(lot.built_far)}; max residential: ${fmt(lot.max_far.residential)}; max commercial: ${fmt(lot.max_far.commercial)}; max community facility: ${fmt(lot.max_far.community_facility)}`,
-            u.estimate_sqft === null
-                ? `Unused floor area: not estimable. ${u.basis}`
-                : u.overbuilt
-                    ? `Unused floor area: about 0 sq ft; existing gross building area (${fmt(lot.building_area_sqft)} sq ft) exceeds the highest FAR MapPLUTO lists (${u.governing_far} x lot area = ${fmt(u.allowed_floor_area_sqft)} sq ft). MapPLUTO building area is gross, not zoning floor area, so this is not evidence of non-compliance. ${u.basis}`
-                    : `Unused floor area (estimate): about ${fmt(u.estimate_sqft, ' sq ft')} of ${fmt(u.allowed_floor_area_sqft)} sq ft allowed. ${u.basis}`,
+            `Recorded MapPLUTO FAR - built: ${fmt(lot.built_far)}; residential: ${fmt(lot.max_far.residential)}; commercial: ${fmt(lot.max_far.commercial)}; community facility: ${fmt(lot.max_far.community_facility)}`,
+            `Unused floor area / development capacity: ${u.basis}.`,
             `Caveat: ${u.caveats.join(' ')}`,
             '',
             source,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "nyrezone-mcp",
-  "version": "0.1.0",
-  "description": "NYRezone MCP - NYC zoning districts and tax-lot lookups (zoning, FAR, unused floor area) from public NYRezone / MapPLUTO data",
+  "version": "0.2.0",
+  "description": "NYRezone MCP - recorded NYC parcel and FAR fields plus NYRezone HTML district summaries",
   "type": "module",
   "bin": { "nyrezone-mcp": "./dist/cli.js" },
   "main": "./dist/server.js",
@@ -15,11 +15,11 @@
   },
   "engines": { "node": ">=20" },
   "dependencies": {
-    "@modelcontextprotocol/server": "2.0.0",
-    "zod": "4.6.5"
+    "@modelcontextprotocol/server": "2.4.0",
+    "zod": "4.6.7"
   },
   "devDependencies": {
-    "@modelcontextprotocol/client": "2.0.0",
+    "@modelcontextprotocol/client": "2.4.0",
     "@types/node": "22.20.3",
     "typescript": "7.0.2"
   },