@fhir-dsl/terminology 0.9.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Abdelhadi Sabani
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.cjs

@@ -0,0 +1,307 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  TerminologyRegistry: () => TerminologyRegistry,
+  parseCodeSystem: () => parseCodeSystem,
+  parseExpansion: () => parseExpansion,
+  parseExpansionsBundle: () => parseExpansionsBundle,
+  resolveCompose: () => resolveCompose,
+  resolveValueSet: () => resolveValueSet
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/codesystem-parser.ts
+function isCodeSystem(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const record = value;
+  return record.resourceType === "CodeSystem";
+}
+function flattenConcepts(concepts) {
+  const result = [];
+  for (const concept of concepts) {
+    if (concept.code) {
+      result.push({
+        code: concept.code,
+        display: concept.display
+      });
+    }
+    if (concept.concept?.length) {
+      result.push(...flattenConcepts(concept.concept));
+    }
+  }
+  return result;
+}
+function parseCodeSystem(resource) {
+  if (!isCodeSystem(resource)) return void 0;
+  const content = normalizeContent(resource.content);
+  return {
+    url: resource.url ?? "",
+    name: resource.name ?? "",
+    content,
+    concepts: content === "complete" && resource.concept?.length ? flattenConcepts(resource.concept) : []
+  };
+}
+function normalizeContent(value) {
+  switch (value) {
+    case "complete":
+    case "not-present":
+    case "example":
+    case "fragment":
+    case "supplement":
+      return value;
+    default:
+      return "not-present";
+  }
+}
+
+// src/expansion-parser.ts
+function isExpandedValueSet(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const record = value;
+  return record.resourceType === "ValueSet" && typeof record.expansion === "object" && record.expansion !== null;
+}
+function flattenContains(contains) {
+  const codes = [];
+  for (const entry of contains) {
+    if (entry.code && !entry.abstract) {
+      codes.push({
+        code: entry.code,
+        display: entry.display,
+        system: entry.system
+      });
+    }
+    if (entry.contains?.length) {
+      codes.push(...flattenContains(entry.contains));
+    }
+  }
+  return codes;
+}
+function parseExpansion(resource) {
+  if (!isExpandedValueSet(resource)) return void 0;
+  if (!resource.expansion?.contains?.length) return void 0;
+  return {
+    url: resource.url ?? "",
+    name: resource.name ?? "",
+    version: resource.version,
+    codes: flattenContains(resource.expansion.contains),
+    isComplete: true
+  };
+}
+function parseExpansionsBundle(bundle) {
+  const result = /* @__PURE__ */ new Map();
+  const entries = extractBundleEntries(bundle);
+  for (const entry of entries) {
+    const resolved = parseExpansion(entry);
+    if (resolved?.url && resolved.codes.length > 0) {
+      result.set(resolved.url, resolved);
+    }
+  }
+  return result;
+}
+function extractBundleEntries(bundle) {
+  if (typeof bundle !== "object" || bundle === null) return [];
+  const record = bundle;
+  if (record.resourceType === "Bundle" && Array.isArray(record.entry)) {
+    return record.entry.filter((e) => typeof e === "object" && e !== null && "resource" in e).map((e) => e.resource);
+  }
+  return [];
+}
+
+// src/valueset-parser.ts
+function isComposeValueSet(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const record = value;
+  return record.resourceType === "ValueSet" && typeof record.compose === "object" && record.compose !== null;
+}
+function resolveCompose(resource, codeSystemLookup) {
+  if (!isComposeValueSet(resource)) return void 0;
+  if (!resource.compose?.include?.length) return void 0;
+  const includedCodes = [];
+  let isComplete = true;
+  for (const include of resource.compose.include) {
+    if (include.concept?.length) {
+      for (const concept of include.concept) {
+        if (concept.code) {
+          includedCodes.push({
+            code: concept.code,
+            display: concept.display,
+            system: include.system
+          });
+        }
+      }
+    } else if (include.filter?.length) {
+      const cs = include.system ? codeSystemLookup.get(include.system) : void 0;
+      if (cs && cs.content === "complete" && cs.concepts.length > 0) {
+        const filtered = applyFilters(cs.concepts, include.filter);
+        includedCodes.push(...filtered.map((c) => ({ ...c, system: include.system })));
+      } else {
+        isComplete = false;
+      }
+    } else if (include.system) {
+      const cs = codeSystemLookup.get(include.system);
+      if (cs && cs.content === "complete" && cs.concepts.length > 0) {
+        includedCodes.push(...cs.concepts.map((c) => ({ ...c, system: include.system })));
+      } else {
+        isComplete = false;
+      }
+    } else {
+      isComplete = false;
+    }
+  }
+  if (resource.compose.exclude?.length) {
+    const excludeSet = /* @__PURE__ */ new Set();
+    for (const exclude of resource.compose.exclude) {
+      if (exclude.concept?.length) {
+        for (const concept of exclude.concept) {
+          if (concept.code) {
+            const key = exclude.system ? `${exclude.system}|${concept.code}` : concept.code;
+            excludeSet.add(key);
+          }
+        }
+      }
+    }
+    if (excludeSet.size > 0) {
+      const filtered = includedCodes.filter((c) => {
+        const key = c.system ? `${c.system}|${c.code}` : c.code;
+        return !excludeSet.has(key);
+      });
+      return {
+        url: resource.url ?? "",
+        name: resource.name ?? "",
+        version: resource.version,
+        codes: filtered,
+        isComplete
+      };
+    }
+  }
+  if (includedCodes.length === 0) return void 0;
+  return {
+    url: resource.url ?? "",
+    name: resource.name ?? "",
+    version: resource.version,
+    codes: includedCodes,
+    isComplete
+  };
+}
+function applyFilters(concepts, filters) {
+  let result = concepts;
+  for (const filter of filters) {
+    if (filter.op === "=" && filter.property === "concept" && filter.value) {
+      result = result.filter((c) => c.code === filter.value);
+    }
+  }
+  return result;
+}
+
+// src/resolver.ts
+function resolveValueSet(valueSetResource, expansions, codeSystems) {
+  const url = extractUrl(valueSetResource);
+  if (!url) return void 0;
+  const expanded = findExpansion(url, expansions);
+  if (expanded) return expanded;
+  return resolveCompose(valueSetResource, codeSystems);
+}
+function extractUrl(resource) {
+  if (typeof resource !== "object" || resource === null) return void 0;
+  const record = resource;
+  return typeof record.url === "string" ? record.url : void 0;
+}
+function findExpansion(url, expansions) {
+  const exact = expansions.get(url);
+  if (exact) return exact;
+  const pipeIdx = url.indexOf("|");
+  if (pipeIdx > 0) {
+    return expansions.get(url.slice(0, pipeIdx));
+  }
+  return void 0;
+}
+
+// src/registry.ts
+var TerminologyRegistry = class {
+  #codeSystems = /* @__PURE__ */ new Map();
+  #expansions = /* @__PURE__ */ new Map();
+  #valueSets = /* @__PURE__ */ new Map();
+  // raw ValueSet resources
+  #resolved = /* @__PURE__ */ new Map();
+  // URL → resolved
+  loadExpansions(entries) {
+    for (const entry of entries) {
+      const resolved = parseExpansion(entry);
+      if (resolved?.url && resolved.codes.length > 0) {
+        this.#expansions.set(resolved.url, resolved);
+      }
+    }
+  }
+  loadCodeSystem(resource) {
+    const cs = parseCodeSystem(resource);
+    if (cs?.url) {
+      this.#codeSystems.set(cs.url, cs);
+    }
+  }
+  loadValueSet(resource) {
+    if (typeof resource !== "object" || resource === null) return;
+    const record = resource;
+    if (typeof record.url === "string") {
+      this.#valueSets.set(record.url, resource);
+    }
+  }
+  resolveAll() {
+    for (const [url, resource] of this.#valueSets) {
+      const resolved = resolveValueSet(resource, this.#expansions, this.#codeSystems);
+      if (resolved && resolved.codes.length > 0) {
+        this.#resolved.set(url, resolved);
+      }
+    }
+    for (const [url, expansion] of this.#expansions) {
+      if (!this.#resolved.has(url)) {
+        this.#resolved.set(url, expansion);
+      }
+    }
+  }
+  resolve(url) {
+    const exact = this.#resolved.get(url);
+    if (exact) return exact;
+    const pipeIdx = url.indexOf("|");
+    if (pipeIdx > 0) {
+      return this.#resolved.get(url.slice(0, pipeIdx));
+    }
+    return void 0;
+  }
+  get resolvedCount() {
+    return this.#resolved.size;
+  }
+  get codeSystemCount() {
+    return this.#codeSystems.size;
+  }
+  allResolved() {
+    return this.#resolved.values();
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TerminologyRegistry,
+  parseCodeSystem,
+  parseExpansion,
+  parseExpansionsBundle,
+  resolveCompose,
+  resolveValueSet
+});

package/dist/index.d.cts

@@ -0,0 +1,42 @@
+interface ResolvedCode {
+    code: string;
+    display?: string | undefined;
+    system?: string | undefined;
+}
+interface ResolvedValueSet {
+    url: string;
+    name: string;
+    version?: string | undefined;
+    codes: ResolvedCode[];
+    /** true if all includes were resolved offline; false if some were skipped */
+    isComplete: boolean;
+}
+interface CodeSystemModel {
+    url: string;
+    name: string;
+    content: "complete" | "not-present" | "example" | "fragment" | "supplement";
+    concepts: ResolvedCode[];
+}
+
+declare function parseCodeSystem(resource: unknown): CodeSystemModel | undefined;
+
+declare function parseExpansion(resource: unknown): ResolvedValueSet | undefined;
+declare function parseExpansionsBundle(bundle: unknown): Map<string, ResolvedValueSet>;
+
+declare class TerminologyRegistry {
+    #private;
+    loadExpansions(entries: unknown[]): void;
+    loadCodeSystem(resource: unknown): void;
+    loadValueSet(resource: unknown): void;
+    resolveAll(): void;
+    resolve(url: string): ResolvedValueSet | undefined;
+    get resolvedCount(): number;
+    get codeSystemCount(): number;
+    allResolved(): IterableIterator<ResolvedValueSet>;
+}
+
+declare function resolveValueSet(valueSetResource: unknown, expansions: Map<string, ResolvedValueSet>, codeSystems: Map<string, CodeSystemModel>): ResolvedValueSet | undefined;
+
+declare function resolveCompose(resource: unknown, codeSystemLookup: Map<string, CodeSystemModel>): ResolvedValueSet | undefined;
+
+export { type CodeSystemModel, type ResolvedCode, type ResolvedValueSet, TerminologyRegistry, parseCodeSystem, parseExpansion, parseExpansionsBundle, resolveCompose, resolveValueSet };

package/dist/index.d.ts

@@ -0,0 +1,42 @@
+interface ResolvedCode {
+    code: string;
+    display?: string | undefined;
+    system?: string | undefined;
+}
+interface ResolvedValueSet {
+    url: string;
+    name: string;
+    version?: string | undefined;
+    codes: ResolvedCode[];
+    /** true if all includes were resolved offline; false if some were skipped */
+    isComplete: boolean;
+}
+interface CodeSystemModel {
+    url: string;
+    name: string;
+    content: "complete" | "not-present" | "example" | "fragment" | "supplement";
+    concepts: ResolvedCode[];
+}
+
+declare function parseCodeSystem(resource: unknown): CodeSystemModel | undefined;
+
+declare function parseExpansion(resource: unknown): ResolvedValueSet | undefined;
+declare function parseExpansionsBundle(bundle: unknown): Map<string, ResolvedValueSet>;
+
+declare class TerminologyRegistry {
+    #private;
+    loadExpansions(entries: unknown[]): void;
+    loadCodeSystem(resource: unknown): void;
+    loadValueSet(resource: unknown): void;
+    resolveAll(): void;
+    resolve(url: string): ResolvedValueSet | undefined;
+    get resolvedCount(): number;
+    get codeSystemCount(): number;
+    allResolved(): IterableIterator<ResolvedValueSet>;
+}
+
+declare function resolveValueSet(valueSetResource: unknown, expansions: Map<string, ResolvedValueSet>, codeSystems: Map<string, CodeSystemModel>): ResolvedValueSet | undefined;
+
+declare function resolveCompose(resource: unknown, codeSystemLookup: Map<string, CodeSystemModel>): ResolvedValueSet | undefined;
+
+export { type CodeSystemModel, type ResolvedCode, type ResolvedValueSet, TerminologyRegistry, parseCodeSystem, parseExpansion, parseExpansionsBundle, resolveCompose, resolveValueSet };

package/dist/index.js

@@ -0,0 +1,275 @@
+// src/codesystem-parser.ts
+function isCodeSystem(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const record = value;
+  return record.resourceType === "CodeSystem";
+}
+function flattenConcepts(concepts) {
+  const result = [];
+  for (const concept of concepts) {
+    if (concept.code) {
+      result.push({
+        code: concept.code,
+        display: concept.display
+      });
+    }
+    if (concept.concept?.length) {
+      result.push(...flattenConcepts(concept.concept));
+    }
+  }
+  return result;
+}
+function parseCodeSystem(resource) {
+  if (!isCodeSystem(resource)) return void 0;
+  const content = normalizeContent(resource.content);
+  return {
+    url: resource.url ?? "",
+    name: resource.name ?? "",
+    content,
+    concepts: content === "complete" && resource.concept?.length ? flattenConcepts(resource.concept) : []
+  };
+}
+function normalizeContent(value) {
+  switch (value) {
+    case "complete":
+    case "not-present":
+    case "example":
+    case "fragment":
+    case "supplement":
+      return value;
+    default:
+      return "not-present";
+  }
+}
+
+// src/expansion-parser.ts
+function isExpandedValueSet(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const record = value;
+  return record.resourceType === "ValueSet" && typeof record.expansion === "object" && record.expansion !== null;
+}
+function flattenContains(contains) {
+  const codes = [];
+  for (const entry of contains) {
+    if (entry.code && !entry.abstract) {
+      codes.push({
+        code: entry.code,
+        display: entry.display,
+        system: entry.system
+      });
+    }
+    if (entry.contains?.length) {
+      codes.push(...flattenContains(entry.contains));
+    }
+  }
+  return codes;
+}
+function parseExpansion(resource) {
+  if (!isExpandedValueSet(resource)) return void 0;
+  if (!resource.expansion?.contains?.length) return void 0;
+  return {
+    url: resource.url ?? "",
+    name: resource.name ?? "",
+    version: resource.version,
+    codes: flattenContains(resource.expansion.contains),
+    isComplete: true
+  };
+}
+function parseExpansionsBundle(bundle) {
+  const result = /* @__PURE__ */ new Map();
+  const entries = extractBundleEntries(bundle);
+  for (const entry of entries) {
+    const resolved = parseExpansion(entry);
+    if (resolved?.url && resolved.codes.length > 0) {
+      result.set(resolved.url, resolved);
+    }
+  }
+  return result;
+}
+function extractBundleEntries(bundle) {
+  if (typeof bundle !== "object" || bundle === null) return [];
+  const record = bundle;
+  if (record.resourceType === "Bundle" && Array.isArray(record.entry)) {
+    return record.entry.filter((e) => typeof e === "object" && e !== null && "resource" in e).map((e) => e.resource);
+  }
+  return [];
+}
+
+// src/valueset-parser.ts
+function isComposeValueSet(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const record = value;
+  return record.resourceType === "ValueSet" && typeof record.compose === "object" && record.compose !== null;
+}
+function resolveCompose(resource, codeSystemLookup) {
+  if (!isComposeValueSet(resource)) return void 0;
+  if (!resource.compose?.include?.length) return void 0;
+  const includedCodes = [];
+  let isComplete = true;
+  for (const include of resource.compose.include) {
+    if (include.concept?.length) {
+      for (const concept of include.concept) {
+        if (concept.code) {
+          includedCodes.push({
+            code: concept.code,
+            display: concept.display,
+            system: include.system
+          });
+        }
+      }
+    } else if (include.filter?.length) {
+      const cs = include.system ? codeSystemLookup.get(include.system) : void 0;
+      if (cs && cs.content === "complete" && cs.concepts.length > 0) {
+        const filtered = applyFilters(cs.concepts, include.filter);
+        includedCodes.push(...filtered.map((c) => ({ ...c, system: include.system })));
+      } else {
+        isComplete = false;
+      }
+    } else if (include.system) {
+      const cs = codeSystemLookup.get(include.system);
+      if (cs && cs.content === "complete" && cs.concepts.length > 0) {
+        includedCodes.push(...cs.concepts.map((c) => ({ ...c, system: include.system })));
+      } else {
+        isComplete = false;
+      }
+    } else {
+      isComplete = false;
+    }
+  }
+  if (resource.compose.exclude?.length) {
+    const excludeSet = /* @__PURE__ */ new Set();
+    for (const exclude of resource.compose.exclude) {
+      if (exclude.concept?.length) {
+        for (const concept of exclude.concept) {
+          if (concept.code) {
+            const key = exclude.system ? `${exclude.system}|${concept.code}` : concept.code;
+            excludeSet.add(key);
+          }
+        }
+      }
+    }
+    if (excludeSet.size > 0) {
+      const filtered = includedCodes.filter((c) => {
+        const key = c.system ? `${c.system}|${c.code}` : c.code;
+        return !excludeSet.has(key);
+      });
+      return {
+        url: resource.url ?? "",
+        name: resource.name ?? "",
+        version: resource.version,
+        codes: filtered,
+        isComplete
+      };
+    }
+  }
+  if (includedCodes.length === 0) return void 0;
+  return {
+    url: resource.url ?? "",
+    name: resource.name ?? "",
+    version: resource.version,
+    codes: includedCodes,
+    isComplete
+  };
+}
+function applyFilters(concepts, filters) {
+  let result = concepts;
+  for (const filter of filters) {
+    if (filter.op === "=" && filter.property === "concept" && filter.value) {
+      result = result.filter((c) => c.code === filter.value);
+    }
+  }
+  return result;
+}
+
+// src/resolver.ts
+function resolveValueSet(valueSetResource, expansions, codeSystems) {
+  const url = extractUrl(valueSetResource);
+  if (!url) return void 0;
+  const expanded = findExpansion(url, expansions);
+  if (expanded) return expanded;
+  return resolveCompose(valueSetResource, codeSystems);
+}
+function extractUrl(resource) {
+  if (typeof resource !== "object" || resource === null) return void 0;
+  const record = resource;
+  return typeof record.url === "string" ? record.url : void 0;
+}
+function findExpansion(url, expansions) {
+  const exact = expansions.get(url);
+  if (exact) return exact;
+  const pipeIdx = url.indexOf("|");
+  if (pipeIdx > 0) {
+    return expansions.get(url.slice(0, pipeIdx));
+  }
+  return void 0;
+}
+
+// src/registry.ts
+var TerminologyRegistry = class {
+  #codeSystems = /* @__PURE__ */ new Map();
+  #expansions = /* @__PURE__ */ new Map();
+  #valueSets = /* @__PURE__ */ new Map();
+  // raw ValueSet resources
+  #resolved = /* @__PURE__ */ new Map();
+  // URL → resolved
+  loadExpansions(entries) {
+    for (const entry of entries) {
+      const resolved = parseExpansion(entry);
+      if (resolved?.url && resolved.codes.length > 0) {
+        this.#expansions.set(resolved.url, resolved);
+      }
+    }
+  }
+  loadCodeSystem(resource) {
+    const cs = parseCodeSystem(resource);
+    if (cs?.url) {
+      this.#codeSystems.set(cs.url, cs);
+    }
+  }
+  loadValueSet(resource) {
+    if (typeof resource !== "object" || resource === null) return;
+    const record = resource;
+    if (typeof record.url === "string") {
+      this.#valueSets.set(record.url, resource);
+    }
+  }
+  resolveAll() {
+    for (const [url, resource] of this.#valueSets) {
+      const resolved = resolveValueSet(resource, this.#expansions, this.#codeSystems);
+      if (resolved && resolved.codes.length > 0) {
+        this.#resolved.set(url, resolved);
+      }
+    }
+    for (const [url, expansion] of this.#expansions) {
+      if (!this.#resolved.has(url)) {
+        this.#resolved.set(url, expansion);
+      }
+    }
+  }
+  resolve(url) {
+    const exact = this.#resolved.get(url);
+    if (exact) return exact;
+    const pipeIdx = url.indexOf("|");
+    if (pipeIdx > 0) {
+      return this.#resolved.get(url.slice(0, pipeIdx));
+    }
+    return void 0;
+  }
+  get resolvedCount() {
+    return this.#resolved.size;
+  }
+  get codeSystemCount() {
+    return this.#codeSystems.size;
+  }
+  allResolved() {
+    return this.#resolved.values();
+  }
+};
+export {
+  TerminologyRegistry,
+  parseCodeSystem,
+  parseExpansion,
+  parseExpansionsBundle,
+  resolveCompose,
+  resolveValueSet
+};

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@fhir-dsl/terminology",
+  "version": "0.9.0",
+  "description": "Compile-time FHIR terminology resolver for ValueSets and CodeSystems",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@fhir-dsl/utils": "0.9.0"
+  },
+  "author": "Abdelhadi Sabani",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/awbx/fhir-dsl.git",
+    "directory": "packages/terminology"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "fhir",
+    "terminology",
+    "valueset",
+    "codesystem",
+    "typescript"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc --noEmit",
+    "dev": "tsup --watch"
+  }
+}