@sjunepark/landprice 0.0.1 → 0.0.3

package/LICENSE.md

@@ -1,47 +1,55 @@
-# Landprice Proprietary License Agreement
+Elastic License 2.0
 
-Copyright (c) 2026 Sejun Park. All rights reserved.
+URL: https://www.elastic.co/licensing/elastic-license
 
-This Landprice Proprietary License Agreement (the "Agreement") governs your access to and use of the Landprice software, including the CLI, bundled files, documentation, updates, and related materials (the "Software").
+Acceptance
 
-## 1. License Grant
+By using the software, you agree to all of the terms and conditions below.
 
-Subject to this Agreement and the accompanying Terms, Sejun Park grants you a limited, revocable, non-exclusive, non-transferable, non-sublicensable license to install and use the Software for personal use or internal business use.
+Copyright License
 
-No ownership rights are transferred. All rights not expressly granted are reserved.
+The licensor grants you a non-exclusive, royalty-free, worldwide, non-sublicensable, non-transferable license to use, copy, distribute, make available, and prepare derivative works of the software, in each case subject to the limitations and conditions below.
 
-## 2. Restrictions
+Limitations
 
-You must not, and must not permit others to:
+You may not provide the software to third parties as a hosted or managed service, where the service provides users with access to any substantial set of the features or functionality of the software.
 
-- copy, redistribute, publish, sublicense, rent, lease, sell, resell, or otherwise transfer the Software;
-- host, expose, wrap, or provide the Software as a service, API, managed service, or hosted tool for third parties;
-- modify, adapt, translate, create derivative works from, or publish modified versions of the Software;
-- reverse engineer, decompile, disassemble, deobfuscate, or otherwise attempt to derive source code, algorithms, or internal implementation details, except to the extent applicable law expressly permits despite this restriction;
-- remove, alter, bypass, or interfere with license notices, access controls, usage controls, authentication, telemetry, rate limits, or other protection mechanisms;
-- use the Software to build, train, benchmark, support, or operate a competing product or service;
-- use the Software for automated abuse, excessive traffic generation, scraping abuse, service disruption, security testing without authorization, or any unlawful purpose.
+You may not move, change, disable, or circumvent the license key functionality in the software, and you may not remove or obscure any functionality in the software that is protected by the license key.
 
-## 3. Commercial Use
+You may not alter, remove, or obscure any licensing, copyright, or other notices of the licensor in the software. Any use of the licensor's trademarks is subject to applicable law.
 
-Internal business use is permitted under this Agreement. External commercial exploitation, including resale, paid hosting, managed access, bundling in a commercial product, or use in a competing offering, requires prior written permission.
+Patents
 
-## 4. Third-Party Services and Data
+The licensor grants you a license, under any patent claims the licensor can license, or becomes able to license, to make, have made, use, sell, offer for sale, import and have imported the software, in each case subject to the limitations and conditions in this license. This license does not cover any patent claims that you cause to be infringed by modifications or additions to the software. If you or your company make any written claim that the software infringes or contributes to infringement of any patent, your patent license for the software granted under these terms ends immediately. If your company makes such a claim, your patent license ends immediately for work on behalf of your company.
 
-The Software may access public RealtyPrice web pages and third-party services. You are responsible for complying with applicable laws, third-party terms, rate limits, and acceptable-use rules. This Agreement does not grant rights to third-party data, websites, APIs, or services.
+Notices
 
-## 5. Termination
+You must ensure that anyone who gets a copy of any part of the software from you also gets a copy of these terms.
 
-This license terminates automatically if you violate this Agreement or the accompanying Terms. Upon termination, you must stop using the Software and delete all copies under your control.
+If you modify the software, you must include in any modified copies of the software prominent notices stating that you have modified the software.
 
-## 6. No Warranty
+No Other Rights
 
-The Software is provided "as is" and "as available," without warranties of any kind, whether express, implied, statutory, or otherwise, including warranties of merchantability, fitness for a particular purpose, title, non-infringement, accuracy, availability, or uninterrupted operation.
+These terms do not imply any licenses other than those expressly granted in these terms.
 
-## 7. Limitation of Liability
+Termination
 
-To the maximum extent permitted by law, Sejun Park will not be liable for any indirect, incidental, special, consequential, exemplary, or punitive damages, or for lost profits, lost revenue, lost data, business interruption, or procurement of substitute services, arising from or related to the Software or this Agreement.
+If you use the software in violation of these terms, such use is not licensed, and your licenses will automatically terminate. If the licensor provides you with a notice of your violation, and you cease all violation of this license no later than 30 days after you receive that notice, your licenses will be reinstated retroactively. However, if you violate these terms after such reinstatement, any additional violation of these terms will cause your licenses to terminate automatically and permanently.
 
-## 8. Changes
+No Liability
 
-This Agreement may be updated from time to time. Continued use of the Software after an updated Agreement is published means you accept the updated Agreement.
+As far as the law allows, the software comes as is, without any warranty or condition, and the licensor will not be liable to you for any damages arising out of these terms or the use or nature of the software, under any kind of legal claim.
+
+Definitions
+
+The licensor is the entity offering these terms, and the software is the software the licensor makes available under these terms, including any portion of it.
+
+you refers to the individual or entity agreeing to these terms.
+
+your company is any legal entity, sole proprietorship, or other kind of organization that you work for, plus all organizations that have control over, are under the control of, or are under common control with that organization. control means ownership of substantially all the assets of an entity, or the power to direct its management and policies by vote, contract, or otherwise. Control can be direct or indirect.
+
+your licenses are all the licenses granted to you for the software under these terms.
+
+use means anything you do with the software requiring one of your licenses.
+
+trademark means trademarks, service marks, and similar rights.

package/README.md

@@ -35,7 +35,7 @@ landprice search-individual-land-prices --years 2026,2025,2024 --district-code 4
 landprice <command> --help
 ```
 
-명령 성공은 표준 출력에 하나의 JSON 응답 객체로 출력됩니다. 명령 실패는 표준 에러에 JSON 실패 객체를 출력하고 0이 아닌 종료 코드로 끝납니다. 도움말 출력은 사람이 읽기 쉬운 텍스트로 유지됩니다.
+명령 성공은 표준 출력에 하나의 JSON 응답 객체로 출력됩니다. 명령 실패도 표준 출력에 하나의 JSON 실패 객체를 출력하고 0이 아닌 종료 코드로 끝납니다. 도움말 출력은 사람이 읽기 쉬운 텍스트로 유지됩니다.
 
 현재 제공하는 주요 작업은 다음과 같습니다.
 
@@ -74,7 +74,7 @@ landprice get-standard-land-price-detail --reference '{"year":2026,"regCode":"11
 
 명령 추가, 선택 입력 필드 추가, 결과 필드 추가, 경고나 메타데이터 추가는 호환 가능한 변경입니다.
 
-현재 표준 통합 지점은 CLI입니다. 별도의 패키지 API, Pi 어댑터, MCP 서버는 아직 공개 계약으로 제공하지 않습니다.
+표준 통합 지점은 CLI, 런타임 중립 TypeScript toolset, Pi 어댑터입니다. toolset은 `@sjunepark/landprice/toolset`에서, Pi 어댑터는 `@sjunepark/landprice/pi`에서 가져올 수 있습니다. MCP 서버는 공개 계약으로 제공하지 않습니다.
 
 ## 주의사항
 
@@ -85,7 +85,7 @@ landprice get-standard-land-price-detail --reference '{"year":2026,"regCode":"11
 
 ## 라이선스
 
-Landprice는 오픈소스가 아닌 독점 소프트웨어입니다. npm 패키지 메타데이터는 `UNLICENSED`이며, 사용 조건은 [`LICENSE.md`](./LICENSE.md)와 [`TERMS.md`](./TERMS.md)를 따릅니다.
+Elastic License 2.0. 자세한 내용은 [`LICENSE.md`](./LICENSE.md)를 참고하세요.
 
 ## 개발
 
@@ -95,6 +95,9 @@ bun run typecheck
 bun test
 bun run build
 node dist/cli.js get-available-years
+
+# Package surfaces after build
+node -e "import('./dist/toolset.js').then(({ createLandpriceToolset }) => console.log(createLandpriceToolset().listOperations().length))"
 ```
 
 릴리스 자동화와 필요한 저장소 설정은 [docs/release.md](docs/release.md)를 참고하세요.

package/dist/app/get-available-years.d.ts

@@ -0,0 +1,14 @@
+import { type ToolRunContext } from "../capabilities/types.ts";
+import { type GetAvailableYearsResult } from "../capabilities/get-available-years/contract.ts";
+import type { GetAvailableYearsProvider } from "../capabilities/get-available-years/provider.ts";
+export declare const getAvailableYearsOperationName: "get-available-years";
+export declare const getAvailableYearsInputJsonSchema: import("effect/JSONSchema").JsonSchema7Root;
+export declare const getAvailableYearsResultJsonSchema: import("effect/JSONSchema").JsonSchema7Root;
+export type GetAvailableYearsOperation = {
+    readonly name: typeof getAvailableYearsOperationName;
+    readonly inputJsonSchema: typeof getAvailableYearsInputJsonSchema;
+    readonly resultJsonSchema: typeof getAvailableYearsResultJsonSchema;
+    readonly execute: (input: Record<string, unknown>, context?: ToolRunContext) => Promise<GetAvailableYearsResult>;
+};
+export declare const createGetAvailableYearsOperation: (provider: GetAvailableYearsProvider) => GetAvailableYearsOperation;
+export declare const defaultGetAvailableYearsOperation: GetAvailableYearsOperation;

package/dist/app/get-standard-land-price-detail.d.ts

@@ -0,0 +1,14 @@
+import { type ToolRunContext } from "../capabilities/types.ts";
+import { type GetStandardLandPriceDetailResult } from "../capabilities/get-standard-land-price-detail/contract.ts";
+import type { GetStandardLandPriceDetailProvider } from "../capabilities/get-standard-land-price-detail/provider.ts";
+export declare const getStandardLandPriceDetailOperationName: "get-standard-land-price-detail";
+export declare const getStandardLandPriceDetailInputJsonSchema: import("effect/JSONSchema").JsonSchema7Root;
+export declare const getStandardLandPriceDetailResultJsonSchema: import("effect/JSONSchema").JsonSchema7Root;
+export type GetStandardLandPriceDetailOperation = {
+    readonly name: typeof getStandardLandPriceDetailOperationName;
+    readonly inputJsonSchema: typeof getStandardLandPriceDetailInputJsonSchema;
+    readonly resultJsonSchema: typeof getStandardLandPriceDetailResultJsonSchema;
+    readonly execute: (input: Record<string, unknown>, context?: ToolRunContext) => Promise<GetStandardLandPriceDetailResult>;
+};
+export declare const createGetStandardLandPriceDetailOperation: (provider: GetStandardLandPriceDetailProvider) => GetStandardLandPriceDetailOperation;
+export declare const defaultGetStandardLandPriceDetailOperation: GetStandardLandPriceDetailOperation;

package/dist/app/list-areas.d.ts

@@ -0,0 +1,14 @@
+import { type ToolRunContext } from "../capabilities/types.ts";
+import { type ListAreasResult } from "../capabilities/list-areas/contract.ts";
+import type { ListAreasProvider } from "../capabilities/list-areas/provider.ts";
+export declare const listAreasOperationName: "list-areas";
+export declare const listAreasInputJsonSchema: import("effect/JSONSchema").JsonSchema7Root;
+export declare const listAreasResultJsonSchema: import("effect/JSONSchema").JsonSchema7Root;
+export type ListAreasOperation = {
+    readonly name: typeof listAreasOperationName;
+    readonly inputJsonSchema: typeof listAreasInputJsonSchema;
+    readonly resultJsonSchema: typeof listAreasResultJsonSchema;
+    readonly execute: (input: Record<string, unknown>, context?: ToolRunContext) => Promise<ListAreasResult>;
+};
+export declare const createListAreasOperation: (provider: ListAreasProvider) => ListAreasOperation;
+export declare const defaultListAreasOperation: ListAreasOperation;

package/dist/app/search-individual-land-prices.d.ts

@@ -0,0 +1,14 @@
+import { type ToolRunContext } from "../capabilities/types.ts";
+import { type SearchIndividualLandPricesResult } from "../capabilities/search-individual-land-prices/contract.ts";
+import type { SearchIndividualLandPricesProvider } from "../capabilities/search-individual-land-prices/provider.ts";
+export declare const searchIndividualLandPricesOperationName: "search-individual-land-prices";
+export declare const searchIndividualLandPricesInputJsonSchema: import("effect/JSONSchema").JsonSchema7Root;
+export declare const searchIndividualLandPricesResultJsonSchema: import("effect/JSONSchema").JsonSchema7Root;
+export type SearchIndividualLandPricesOperation = {
+    readonly name: typeof searchIndividualLandPricesOperationName;
+    readonly inputJsonSchema: typeof searchIndividualLandPricesInputJsonSchema;
+    readonly resultJsonSchema: typeof searchIndividualLandPricesResultJsonSchema;
+    readonly execute: (input: Record<string, unknown>, context?: ToolRunContext) => Promise<SearchIndividualLandPricesResult>;
+};
+export declare const createSearchIndividualLandPricesOperation: (provider: SearchIndividualLandPricesProvider) => SearchIndividualLandPricesOperation;
+export declare const defaultSearchIndividualLandPricesOperation: SearchIndividualLandPricesOperation;

package/dist/app/search-standard-land-prices.d.ts

@@ -0,0 +1,14 @@
+import { type ToolRunContext } from "../capabilities/types.ts";
+import { type SearchStandardLandPricesResult } from "../capabilities/search-standard-land-prices/contract.ts";
+import type { SearchStandardLandPricesProvider } from "../capabilities/search-standard-land-prices/provider.ts";
+export declare const searchStandardLandPricesOperationName: "search-standard-land-prices";
+export declare const searchStandardLandPricesInputJsonSchema: import("effect/JSONSchema").JsonSchema7Root;
+export declare const searchStandardLandPricesResultJsonSchema: import("effect/JSONSchema").JsonSchema7Root;
+export type SearchStandardLandPricesOperation = {
+    readonly name: typeof searchStandardLandPricesOperationName;
+    readonly inputJsonSchema: typeof searchStandardLandPricesInputJsonSchema;
+    readonly resultJsonSchema: typeof searchStandardLandPricesResultJsonSchema;
+    readonly execute: (input: Record<string, unknown>, context?: ToolRunContext) => Promise<SearchStandardLandPricesResult>;
+};
+export declare const createSearchStandardLandPricesOperation: (provider: SearchStandardLandPricesProvider) => SearchStandardLandPricesOperation;
+export declare const defaultSearchStandardLandPricesOperation: SearchStandardLandPricesOperation;

package/dist/capabilities/get-available-years/contract.d.ts

@@ -0,0 +1,78 @@
+import { Schema } from "effect";
+import { type SuccessEnvelope } from "../types.ts";
+export declare const GetAvailableYearsInputSchema: Schema.Struct<{
+    responseDetail: Schema.optional<Schema.Literal<["concise", "raw"]>>;
+}>;
+export type GetAvailableYearsRawInput = typeof GetAvailableYearsInputSchema.Encoded;
+export declare const YearRangeSchema: Schema.Struct<{
+    startYear: typeof Schema.Int;
+    endYear: typeof Schema.Int;
+    years: Schema.Array$<typeof Schema.Int>;
+}>;
+export type YearRange = typeof YearRangeSchema.Type;
+export declare const GetAvailableYearsResultPayloadSchema: Schema.Struct<{
+    standardLandSearchYears: Schema.Struct<{
+        startYear: typeof Schema.Int;
+        endYear: typeof Schema.Int;
+        years: Schema.Array$<typeof Schema.Int>;
+    }>;
+    noticeDateSearchYears: Schema.Struct<{
+        startYear: typeof Schema.Int;
+        endYear: typeof Schema.Int;
+        years: Schema.Array$<typeof Schema.Int>;
+    }>;
+    sourceObserved: typeof Schema.Boolean;
+    raw: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.String>>;
+}>;
+export type GetAvailableYearsResultPayload = typeof GetAvailableYearsResultPayloadSchema.Type;
+export declare const GetAvailableYearsResultSchema: Schema.Struct<{
+    result: Schema.Struct<{
+        standardLandSearchYears: Schema.Struct<{
+            startYear: typeof Schema.Int;
+            endYear: typeof Schema.Int;
+            years: Schema.Array$<typeof Schema.Int>;
+        }>;
+        noticeDateSearchYears: Schema.Struct<{
+            startYear: typeof Schema.Int;
+            endYear: typeof Schema.Int;
+            years: Schema.Array$<typeof Schema.Int>;
+        }>;
+        sourceObserved: typeof Schema.Boolean;
+        raw: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.String>>;
+    }>;
+    metadata: Schema.Struct<{
+        sourceSystem: Schema.Literal<["realtyprice"]>;
+        sourcePage: Schema.Literal<["https://www.realtyprice.kr/notice/gsstandard/search.htm", "https://www.realtyprice.kr/notice/gsindividual/search.htm"]>;
+        endpoint: typeof Schema.String;
+        query: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.Any>>;
+        retrievedAt: typeof Schema.String;
+        completeness: Schema.Literal<["complete", "empty", "partial", "unknown"]>;
+        sourceBehavior: typeof Schema.String;
+    }>;
+    references: Schema.Array$<Schema.Struct<{
+        type: Schema.Literal<["sourcePage", "endpoint", "area", "standardLandRecord", "individualLandRecord", "detail"]>;
+        sourceUrl: typeof Schema.String;
+        standardLandReference: Schema.optional<Schema.Struct<{
+            year: Schema.refine<number, typeof Schema.Number>;
+            regCode: Schema.SchemaClass<string, string, never>;
+            eubCode: Schema.SchemaClass<string, string, never>;
+            sourceSanFlag: Schema.SchemaClass<string, string, never>;
+            bun1: Schema.SchemaClass<string, string, never>;
+            bun2: Schema.SchemaClass<string, string, never>;
+            standardLandNumber: Schema.optional<Schema.SchemaClass<string, string, never>>;
+        }>>;
+        individualLandReference: Schema.optional<Schema.Struct<{
+            year: Schema.refine<number, typeof Schema.Number>;
+            regCode: Schema.SchemaClass<string, string, never>;
+            eubCode: Schema.SchemaClass<string, string, never>;
+            sourceSanFlag: Schema.SchemaClass<string, string, never>;
+            bun1: Schema.SchemaClass<string, string, never>;
+            bun2: Schema.SchemaClass<string, string, never>;
+        }>>;
+    }>>;
+    warnings: Schema.Array$<Schema.Union<[typeof Schema.String, Schema.Struct<{
+        code: typeof Schema.String;
+        message: typeof Schema.String;
+    }>]>>;
+}>;
+export type GetAvailableYearsResult = SuccessEnvelope<GetAvailableYearsResultPayload>;

package/dist/capabilities/get-available-years/execute.d.ts

@@ -0,0 +1,7 @@
+import { type ResponseDetail, type ToolRunContext } from "../types.ts";
+import type { GetAvailableYearsResult } from "./contract.ts";
+import type { GetAvailableYearsProvider } from "./provider.ts";
+export declare const resolveGetAvailableYearsRequest: (input: Record<string, unknown>) => {
+    readonly responseDetail: ResponseDetail;
+};
+export declare const executeGetAvailableYears: (input: Record<string, unknown>, provider: GetAvailableYearsProvider, context?: ToolRunContext) => Promise<GetAvailableYearsResult>;

package/dist/capabilities/get-available-years/provider.d.ts

@@ -0,0 +1,7 @@
+import type { ResponseDetail, ToolRunContext } from "../types.ts";
+import type { GetAvailableYearsResult } from "./contract.ts";
+export type GetAvailableYearsProvider = {
+    readonly getAvailableYears: (request: {
+        readonly responseDetail: ResponseDetail;
+    }, context?: ToolRunContext) => Promise<GetAvailableYearsResult>;
+};

package/dist/capabilities/get-standard-land-price-detail/contract.d.ts

@@ -0,0 +1,152 @@
+import { Schema } from "effect";
+import { type ResponseDetail, type StandardLandReference, type SuccessEnvelope } from "../types.ts";
+export declare const GetStandardLandPriceDetailInputSchema: Schema.Struct<{
+    standardLandReference: Schema.Struct<{
+        year: Schema.refine<number, typeof Schema.Number>;
+        regCode: Schema.SchemaClass<string, string, never>;
+        eubCode: Schema.SchemaClass<string, string, never>;
+        sourceSanFlag: Schema.SchemaClass<string, string, never>;
+        bun1: Schema.SchemaClass<string, string, never>;
+        bun2: Schema.SchemaClass<string, string, never>;
+        standardLandNumber: Schema.optional<Schema.SchemaClass<string, string, never>>;
+    }>;
+    responseDetail: Schema.optional<Schema.Literal<["concise", "raw"]>>;
+}>;
+export type GetStandardLandPriceDetailRawInput = typeof GetStandardLandPriceDetailInputSchema.Encoded;
+export type GetStandardLandPriceDetailRequest = {
+    readonly standardLandReference: StandardLandReference;
+    readonly responseDetail: ResponseDetail;
+};
+export declare const ReferencePriceDataSchema: Schema.Struct<{
+    kind: Schema.NullOr<typeof Schema.String>;
+    address: Schema.NullOr<typeof Schema.String>;
+    zoning: Schema.NullOr<typeof Schema.String>;
+    landAreaDisplay: Schema.NullOr<typeof Schema.String>;
+    buildingYear: Schema.NullOr<typeof Schema.String>;
+    buildingAreaDisplay: Schema.NullOr<typeof Schema.String>;
+    date: Schema.NullOr<typeof Schema.String>;
+    priceDisplay: Schema.NullOr<typeof Schema.String>;
+}>;
+export type ReferencePriceData = typeof ReferencePriceDataSchema.Type;
+export declare const StandardLandPriceDetailSchema: Schema.Struct<{
+    standardLandReference: Schema.Struct<{
+        year: Schema.refine<number, typeof Schema.Number>;
+        regCode: Schema.SchemaClass<string, string, never>;
+        eubCode: Schema.SchemaClass<string, string, never>;
+        sourceSanFlag: Schema.SchemaClass<string, string, never>;
+        bun1: Schema.SchemaClass<string, string, never>;
+        bun2: Schema.SchemaClass<string, string, never>;
+        standardLandNumber: Schema.optional<Schema.SchemaClass<string, string, never>>;
+    }>;
+    address: Schema.NullOr<typeof Schema.String>;
+    roadAddress: Schema.NullOr<typeof Schema.String>;
+    areaSquareMeters: Schema.optional<typeof Schema.Number>;
+    areaDisplay: Schema.NullOr<typeof Schema.String>;
+    previousOfficialPricePerSquareMeter: Schema.optional<typeof Schema.Number>;
+    officialPricePerSquareMeter: Schema.optional<typeof Schema.Number>;
+    locationDescription: Schema.NullOr<typeof Schema.String>;
+    surroundingEnvironment: Schema.NullOr<typeof Schema.String>;
+    landCategory: Schema.NullOr<typeof Schema.String>;
+    zoning: Schema.NullOr<typeof Schema.String>;
+    district: Schema.NullOr<typeof Schema.String>;
+    planningFacility: Schema.NullOr<typeof Schema.String>;
+    constraintRatio: Schema.NullOr<typeof Schema.String>;
+    roadFrontage: Schema.NullOr<typeof Schema.String>;
+    shape: Schema.NullOr<typeof Schema.String>;
+    elevation: Schema.NullOr<typeof Schema.String>;
+    useStatus: Schema.NullOr<typeof Schema.String>;
+    representativeParcel: Schema.optional<typeof Schema.Boolean>;
+    hazardAccess: Schema.NullOr<typeof Schema.String>;
+    referencePriceData: Schema.Struct<{
+        kind: Schema.NullOr<typeof Schema.String>;
+        address: Schema.NullOr<typeof Schema.String>;
+        zoning: Schema.NullOr<typeof Schema.String>;
+        landAreaDisplay: Schema.NullOr<typeof Schema.String>;
+        buildingYear: Schema.NullOr<typeof Schema.String>;
+        buildingAreaDisplay: Schema.NullOr<typeof Schema.String>;
+        date: Schema.NullOr<typeof Schema.String>;
+        priceDisplay: Schema.NullOr<typeof Schema.String>;
+    }>;
+    valuationOpinion: Schema.NullOr<typeof Schema.String>;
+    raw: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.Any>>;
+}>;
+export type StandardLandPriceDetail = typeof StandardLandPriceDetailSchema.Type;
+export declare const GetStandardLandPriceDetailResultSchema: Schema.Struct<{
+    result: Schema.Struct<{
+        standardLandReference: Schema.Struct<{
+            year: Schema.refine<number, typeof Schema.Number>;
+            regCode: Schema.SchemaClass<string, string, never>;
+            eubCode: Schema.SchemaClass<string, string, never>;
+            sourceSanFlag: Schema.SchemaClass<string, string, never>;
+            bun1: Schema.SchemaClass<string, string, never>;
+            bun2: Schema.SchemaClass<string, string, never>;
+            standardLandNumber: Schema.optional<Schema.SchemaClass<string, string, never>>;
+        }>;
+        address: Schema.NullOr<typeof Schema.String>;
+        roadAddress: Schema.NullOr<typeof Schema.String>;
+        areaSquareMeters: Schema.optional<typeof Schema.Number>;
+        areaDisplay: Schema.NullOr<typeof Schema.String>;
+        previousOfficialPricePerSquareMeter: Schema.optional<typeof Schema.Number>;
+        officialPricePerSquareMeter: Schema.optional<typeof Schema.Number>;
+        locationDescription: Schema.NullOr<typeof Schema.String>;
+        surroundingEnvironment: Schema.NullOr<typeof Schema.String>;
+        landCategory: Schema.NullOr<typeof Schema.String>;
+        zoning: Schema.NullOr<typeof Schema.String>;
+        district: Schema.NullOr<typeof Schema.String>;
+        planningFacility: Schema.NullOr<typeof Schema.String>;
+        constraintRatio: Schema.NullOr<typeof Schema.String>;
+        roadFrontage: Schema.NullOr<typeof Schema.String>;
+        shape: Schema.NullOr<typeof Schema.String>;
+        elevation: Schema.NullOr<typeof Schema.String>;
+        useStatus: Schema.NullOr<typeof Schema.String>;
+        representativeParcel: Schema.optional<typeof Schema.Boolean>;
+        hazardAccess: Schema.NullOr<typeof Schema.String>;
+        referencePriceData: Schema.Struct<{
+            kind: Schema.NullOr<typeof Schema.String>;
+            address: Schema.NullOr<typeof Schema.String>;
+            zoning: Schema.NullOr<typeof Schema.String>;
+            landAreaDisplay: Schema.NullOr<typeof Schema.String>;
+            buildingYear: Schema.NullOr<typeof Schema.String>;
+            buildingAreaDisplay: Schema.NullOr<typeof Schema.String>;
+            date: Schema.NullOr<typeof Schema.String>;
+            priceDisplay: Schema.NullOr<typeof Schema.String>;
+        }>;
+        valuationOpinion: Schema.NullOr<typeof Schema.String>;
+        raw: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.Any>>;
+    }>;
+    metadata: Schema.Struct<{
+        sourceSystem: Schema.Literal<["realtyprice"]>;
+        sourcePage: Schema.Literal<["https://www.realtyprice.kr/notice/gsstandard/search.htm", "https://www.realtyprice.kr/notice/gsindividual/search.htm"]>;
+        endpoint: typeof Schema.String;
+        query: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.Any>>;
+        retrievedAt: typeof Schema.String;
+        completeness: Schema.Literal<["complete", "empty", "partial", "unknown"]>;
+        sourceBehavior: typeof Schema.String;
+    }>;
+    references: Schema.Array$<Schema.Struct<{
+        type: Schema.Literal<["sourcePage", "endpoint", "area", "standardLandRecord", "individualLandRecord", "detail"]>;
+        sourceUrl: typeof Schema.String;
+        standardLandReference: Schema.optional<Schema.Struct<{
+            year: Schema.refine<number, typeof Schema.Number>;
+            regCode: Schema.SchemaClass<string, string, never>;
+            eubCode: Schema.SchemaClass<string, string, never>;
+            sourceSanFlag: Schema.SchemaClass<string, string, never>;
+            bun1: Schema.SchemaClass<string, string, never>;
+            bun2: Schema.SchemaClass<string, string, never>;
+            standardLandNumber: Schema.optional<Schema.SchemaClass<string, string, never>>;
+        }>>;
+        individualLandReference: Schema.optional<Schema.Struct<{
+            year: Schema.refine<number, typeof Schema.Number>;
+            regCode: Schema.SchemaClass<string, string, never>;
+            eubCode: Schema.SchemaClass<string, string, never>;
+            sourceSanFlag: Schema.SchemaClass<string, string, never>;
+            bun1: Schema.SchemaClass<string, string, never>;
+            bun2: Schema.SchemaClass<string, string, never>;
+        }>>;
+    }>>;
+    warnings: Schema.Array$<Schema.Union<[typeof Schema.String, Schema.Struct<{
+        code: typeof Schema.String;
+        message: typeof Schema.String;
+    }>]>>;
+}>;
+export type GetStandardLandPriceDetailResult = SuccessEnvelope<StandardLandPriceDetail>;

package/dist/capabilities/get-standard-land-price-detail/execute.d.ts

@@ -0,0 +1,5 @@
+import { type ToolRunContext } from "../types.ts";
+import type { GetStandardLandPriceDetailRequest, GetStandardLandPriceDetailResult } from "./contract.ts";
+import type { GetStandardLandPriceDetailProvider } from "./provider.ts";
+export declare const resolveGetStandardLandPriceDetailRequest: (input: Record<string, unknown>) => GetStandardLandPriceDetailRequest;
+export declare const executeGetStandardLandPriceDetail: (input: Record<string, unknown>, provider: GetStandardLandPriceDetailProvider, context?: ToolRunContext) => Promise<GetStandardLandPriceDetailResult>;

package/dist/capabilities/get-standard-land-price-detail/provider.d.ts

@@ -0,0 +1,5 @@
+import type { ToolRunContext } from "../types.ts";
+import type { GetStandardLandPriceDetailRequest, GetStandardLandPriceDetailResult } from "./contract.ts";
+export type GetStandardLandPriceDetailProvider = {
+    readonly getStandardLandPriceDetail: (request: GetStandardLandPriceDetailRequest, context?: ToolRunContext) => Promise<GetStandardLandPriceDetailResult>;
+};

package/dist/capabilities/list-areas/contract.d.ts

@@ -0,0 +1,106 @@
+import { Schema } from "effect";
+import { type AreaLevel, type AreaSurface, type ResponseDetail, type SearchMode, type SuccessEnvelope } from "../types.ts";
+export declare const ListAreasInputSchema: Schema.Struct<{
+    year: typeof Schema.Int;
+    searchMode: Schema.optional<Schema.Literal<["current-address", "notice-date"]>>;
+    surface: Schema.optional<Schema.Literal<["standard-land", "individual-land"]>>;
+    level: Schema.Literal<["sido", "district", "legal-dong"]>;
+    sidoCode: Schema.optional<typeof Schema.String>;
+    districtCode: Schema.optional<typeof Schema.String>;
+    responseDetail: Schema.optional<Schema.Literal<["concise", "raw"]>>;
+}>;
+export type ListAreasRawInput = typeof ListAreasInputSchema.Encoded;
+export type ListAreasRequest = {
+    readonly year: number;
+    readonly searchMode: SearchMode;
+    readonly surface: AreaSurface;
+    readonly level: AreaLevel;
+    readonly sidoCode?: string;
+    readonly districtCode?: string;
+    readonly responseDetail: ResponseDetail;
+};
+export declare const AreaSchema: Schema.Struct<{
+    code: typeof Schema.String;
+    name: typeof Schema.String;
+    sidoCode: Schema.optional<typeof Schema.String>;
+    districtCode: Schema.optional<typeof Schema.String>;
+    legalDongCode: Schema.optional<typeof Schema.String>;
+    source: Schema.Record$<typeof Schema.String, typeof Schema.String>;
+}>;
+export type Area = typeof AreaSchema.Type;
+export declare const ListAreasResultPayloadSchema: Schema.Struct<{
+    year: typeof Schema.Int;
+    searchMode: Schema.Literal<["current-address", "notice-date"]>;
+    surface: Schema.Literal<["standard-land", "individual-land"]>;
+    level: Schema.Literal<["sido", "district", "legal-dong"]>;
+    parent: Schema.Struct<{
+        sidoCode: Schema.optional<typeof Schema.String>;
+        districtCode: Schema.optional<typeof Schema.String>;
+    }>;
+    areas: Schema.Array$<Schema.Struct<{
+        code: typeof Schema.String;
+        name: typeof Schema.String;
+        sidoCode: Schema.optional<typeof Schema.String>;
+        districtCode: Schema.optional<typeof Schema.String>;
+        legalDongCode: Schema.optional<typeof Schema.String>;
+        source: Schema.Record$<typeof Schema.String, typeof Schema.String>;
+    }>>;
+    raw: Schema.optional<typeof Schema.Any>;
+}>;
+export type ListAreasResultPayload = typeof ListAreasResultPayloadSchema.Type;
+export declare const ListAreasResultSchema: Schema.Struct<{
+    result: Schema.Struct<{
+        year: typeof Schema.Int;
+        searchMode: Schema.Literal<["current-address", "notice-date"]>;
+        surface: Schema.Literal<["standard-land", "individual-land"]>;
+        level: Schema.Literal<["sido", "district", "legal-dong"]>;
+        parent: Schema.Struct<{
+            sidoCode: Schema.optional<typeof Schema.String>;
+            districtCode: Schema.optional<typeof Schema.String>;
+        }>;
+        areas: Schema.Array$<Schema.Struct<{
+            code: typeof Schema.String;
+            name: typeof Schema.String;
+            sidoCode: Schema.optional<typeof Schema.String>;
+            districtCode: Schema.optional<typeof Schema.String>;
+            legalDongCode: Schema.optional<typeof Schema.String>;
+            source: Schema.Record$<typeof Schema.String, typeof Schema.String>;
+        }>>;
+        raw: Schema.optional<typeof Schema.Any>;
+    }>;
+    metadata: Schema.Struct<{
+        sourceSystem: Schema.Literal<["realtyprice"]>;
+        sourcePage: Schema.Literal<["https://www.realtyprice.kr/notice/gsstandard/search.htm", "https://www.realtyprice.kr/notice/gsindividual/search.htm"]>;
+        endpoint: typeof Schema.String;
+        query: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.Any>>;
+        retrievedAt: typeof Schema.String;
+        completeness: Schema.Literal<["complete", "empty", "partial", "unknown"]>;
+        sourceBehavior: typeof Schema.String;
+    }>;
+    references: Schema.Array$<Schema.Struct<{
+        type: Schema.Literal<["sourcePage", "endpoint", "area", "standardLandRecord", "individualLandRecord", "detail"]>;
+        sourceUrl: typeof Schema.String;
+        standardLandReference: Schema.optional<Schema.Struct<{
+            year: Schema.refine<number, typeof Schema.Number>;
+            regCode: Schema.SchemaClass<string, string, never>;
+            eubCode: Schema.SchemaClass<string, string, never>;
+            sourceSanFlag: Schema.SchemaClass<string, string, never>;
+            bun1: Schema.SchemaClass<string, string, never>;
+            bun2: Schema.SchemaClass<string, string, never>;
+            standardLandNumber: Schema.optional<Schema.SchemaClass<string, string, never>>;
+        }>>;
+        individualLandReference: Schema.optional<Schema.Struct<{
+            year: Schema.refine<number, typeof Schema.Number>;
+            regCode: Schema.SchemaClass<string, string, never>;
+            eubCode: Schema.SchemaClass<string, string, never>;
+            sourceSanFlag: Schema.SchemaClass<string, string, never>;
+            bun1: Schema.SchemaClass<string, string, never>;
+            bun2: Schema.SchemaClass<string, string, never>;
+        }>>;
+    }>>;
+    warnings: Schema.Array$<Schema.Union<[typeof Schema.String, Schema.Struct<{
+        code: typeof Schema.String;
+        message: typeof Schema.String;
+    }>]>>;
+}>;
+export type ListAreasResult = SuccessEnvelope<ListAreasResultPayload>;

package/dist/capabilities/list-areas/execute.d.ts

@@ -0,0 +1,5 @@
+import { type ToolRunContext } from "../types.ts";
+import type { ListAreasRequest, ListAreasResult } from "./contract.ts";
+import type { ListAreasProvider } from "./provider.ts";
+export declare const resolveListAreasRequest: (input: Record<string, unknown>) => ListAreasRequest;
+export declare const executeListAreas: (input: Record<string, unknown>, provider: ListAreasProvider, context?: ToolRunContext) => Promise<ListAreasResult>;

package/dist/capabilities/list-areas/provider.d.ts

@@ -0,0 +1,5 @@
+import type { ToolRunContext } from "../types.ts";
+import type { ListAreasRequest, ListAreasResult } from "./contract.ts";
+export type ListAreasProvider = {
+    readonly listAreas: (request: ListAreasRequest, context?: ToolRunContext) => Promise<ListAreasResult>;
+};

package/dist/capabilities/request-validation.d.ts

@@ -0,0 +1,14 @@
+import { type AreaLevel, type AreaSurface, type ResponseDetail, type SearchMode } from "./types.ts";
+export declare function assertObjectInput(input: unknown): asserts input is Record<string, unknown>;
+export declare const assertNoUnknownKeys: (input: Record<string, unknown>, allowedKeys: ReadonlySet<string>) => void;
+export declare const readOptionalResponseDetail: (input: Record<string, unknown>) => ResponseDetail;
+export declare const readOptionalSearchMode: (input: Record<string, unknown>) => SearchMode;
+export declare const readOptionalAreaSurface: (input: Record<string, unknown>) => AreaSurface;
+export declare const readRequiredAreaLevel: (input: Record<string, unknown>) => AreaLevel;
+export declare const readRequiredInteger: (input: Record<string, unknown>, key: string) => number;
+export declare const readOptionalInteger: (input: Record<string, unknown>, key: string, defaultValue: number) => number;
+export declare const readOptionalIntegerArray: (input: Record<string, unknown>, key: string) => readonly number[] | undefined;
+export declare const readOptionalString: (input: Record<string, unknown>, key: string) => string | undefined;
+export declare const readRequiredString: (input: Record<string, unknown>, key: string) => string;
+export declare const assertDigits: (key: string, value: string, length: number) => void;
+export declare const assertMinInteger: (key: string, value: number, min: number) => void;