@reapi/spec-ui 0.1.0

package/dist/chunk-WO4ZCICV.js

@@ -0,0 +1,333 @@
+// src/schema/types.ts
+var SCHEMA_TYPE_OPTIONS = [
+  "object",
+  "array",
+  "string",
+  "number",
+  "integer",
+  "boolean",
+  "null"
+];
+var COMPOSITE_KEYWORDS = ["allOf", "oneOf", "anyOf"];
+
+// src/schema/guards.ts
+function isRef(s) {
+  return !!s && typeof s === "object" && typeof s.$ref === "string";
+}
+function compositeKeyword(s) {
+  if (!s || isRef(s)) return null;
+  for (const kw of COMPOSITE_KEYWORDS) {
+    if (Array.isArray(s[kw])) return kw;
+  }
+  return null;
+}
+function schemaKind(s) {
+  if (!s || typeof s !== "object") return "any";
+  if (isRef(s)) return "ref";
+  const schema = s;
+  if (compositeKeyword(schema)) return "composite";
+  if (schema.type === "object" || schema.properties) return "object";
+  if (schema.type === "array" || schema.items) return "array";
+  if (Array.isArray(schema.enum)) return "enum";
+  if (schema.type) return "primitive";
+  return "any";
+}
+function schemaTypeLabel(s) {
+  if (!s || typeof s !== "object") return "any";
+  if (isRef(s)) return refName(s.$ref);
+  const schema = s;
+  const kw = compositeKeyword(schema);
+  if (kw) return kw;
+  if (schemaKind(schema) === "array") {
+    const inner = schema.items ? schemaTypeLabel(schema.items) : "any";
+    return `array<${inner}>`;
+  }
+  if (Array.isArray(schema.enum)) return `enum<${schema.type ?? "string"}>`;
+  return schema.type ?? "any";
+}
+function refName(ref) {
+  const seg = ref.split("/").pop();
+  return seg ? decodeURIComponent(seg) : ref;
+}
+
+// src/schema/create-schema.ts
+var RETAINED_KEYS = [
+  "title",
+  "description",
+  "nullable",
+  "readOnly",
+  "writeOnly",
+  "deprecated",
+  "x-internal",
+  "x-debug"
+];
+function retainedMetadata(prev) {
+  if (!prev || isRef(prev)) return {};
+  const out = {};
+  for (const key of RETAINED_KEYS) {
+    const v = prev[key];
+    if (v !== void 0) out[key] = v;
+  }
+  return out;
+}
+function baseForType(type) {
+  switch (type) {
+    case "object":
+      return { type: "object", properties: {} };
+    case "array":
+      return { type: "array", items: { type: "string" } };
+    default:
+      return { type };
+  }
+}
+function createSchemaForType(type, prev) {
+  return { ...baseForType(type), ...retainedMetadata(prev) };
+}
+function createCompositeSchema(keyword, prev) {
+  const seed = [];
+  if (prev && (isRef(prev) || prev.type)) {
+    if (isRef(prev)) {
+      seed.push(prev);
+    } else {
+      const clone = { ...prev };
+      for (const key of RETAINED_KEYS) delete clone[key];
+      if (Object.keys(clone).length) seed.push(clone);
+    }
+  }
+  return { [keyword]: seed, ...retainedMetadata(prev) };
+}
+function createRefSchema(ref) {
+  return { $ref: ref };
+}
+
+// src/schema/patch.ts
+function applyPatch(schema, patch) {
+  const next = { ...schema };
+  for (const [key, value] of Object.entries(patch)) {
+    if (value === void 0) delete next[key];
+    else next[key] = value;
+  }
+  return next;
+}
+
+// src/schema/object-utils.ts
+function renameKey(record, oldKey, newKey) {
+  if (oldKey === newKey || !(oldKey in record) || newKey in record) return record;
+  const next = {};
+  for (const [k, v] of Object.entries(record)) {
+    next[k === oldKey ? newKey : k] = v;
+  }
+  return next;
+}
+function uniqueKey(record, base = "property") {
+  if (!(base in record)) return base;
+  let i = 2;
+  while (`${base}${i}` in record) i++;
+  return `${base}${i}`;
+}
+function insertKeyAt(record, key, value, index) {
+  const entries = Object.entries(record).filter(([k]) => k !== key);
+  const clamped = Math.max(0, Math.min(entries.length, index));
+  entries.splice(clamped, 0, [key, value]);
+  return Object.fromEntries(entries);
+}
+function moveKey(record, key, toIndex) {
+  const entries = Object.entries(record);
+  const from = entries.findIndex(([k]) => k === key);
+  if (from === -1) return record;
+  const clamped = Math.max(0, Math.min(entries.length - 1, toIndex));
+  if (clamped === from) return record;
+  const [entry] = entries.splice(from, 1);
+  entries.splice(clamped, 0, entry);
+  return Object.fromEntries(entries);
+}
+
+// src/schema/refs.ts
+var SHARED_SLUG = "shared";
+function extractRefOptions(spec) {
+  const components = spec.components ?? {};
+  const schemas = components.schemas ?? {};
+  return Object.keys(schemas).map((name) => `#/components/schemas/${name}`);
+}
+function extractSharedRefOptions(sharedSpec) {
+  return extractRefOptions(sharedSpec).map((ref) => `${SHARED_SLUG}${ref}`);
+}
+function isSharedRef(ref) {
+  return ref.startsWith(`${SHARED_SLUG}#/`);
+}
+function buildSharedRef(name) {
+  return `${SHARED_SLUG}#/components/schemas/${name}`;
+}
+function walkRefs(node, path = [], out = []) {
+  if (Array.isArray(node)) {
+    node.forEach((item, i) => walkRefs(item, [...path, i], out));
+  } else if (node && typeof node === "object") {
+    const obj = node;
+    if (typeof obj.$ref === "string") out.push({ path, ref: obj.$ref });
+    for (const [key, value] of Object.entries(obj)) walkRefs(value, [...path, key], out);
+  }
+  return out;
+}
+function resolvePointer(spec, pointer) {
+  const hash = pointer.startsWith("#") ? pointer.slice(1) : pointer;
+  if (!hash.startsWith("/")) return void 0;
+  let cur = spec;
+  for (const raw of hash.slice(1).split("/")) {
+    const seg = raw.replace(/~1/g, "/").replace(/~0/g, "~");
+    if (cur == null || typeof cur !== "object") return void 0;
+    cur = cur[seg];
+  }
+  return cur;
+}
+function findDanglingRefs(spec, sharedSpec) {
+  return walkRefs(spec).filter(({ ref }) => {
+    if (ref.startsWith("#/")) return resolvePointer(spec, ref) === void 0;
+    if (isSharedRef(ref)) {
+      if (!sharedSpec) return true;
+      return resolvePointer(sharedSpec, ref.slice(SHARED_SLUG.length)) === void 0;
+    }
+    return false;
+  });
+}
+
+// src/schema/component-skeleton.ts
+function camelCase(name) {
+  const parts = name.split(/[^a-zA-Z0-9]+/).filter(Boolean);
+  return parts.map((p, i) => i === 0 ? p[0].toLowerCase() + p.slice(1) : p[0].toUpperCase() + p.slice(1)).join("");
+}
+function componentSkeleton(typeKey, name) {
+  switch (typeKey) {
+    case "schemas":
+      return { type: "object", properties: {} };
+    case "responses":
+      return { description: name };
+    case "parameters":
+      return { name: camelCase(name), in: "query", schema: { type: "string" } };
+    case "requestBodies":
+      return {
+        content: { "application/json": { schema: { type: "object", properties: {} } } }
+      };
+    case "examples":
+      return { summary: name, value: {} };
+    case "headers":
+      return { schema: { type: "string" } };
+    case "securitySchemes":
+      return { type: "apiKey", name: camelCase(name), in: "header" };
+    default:
+      return {};
+  }
+}
+var COMPONENT_NAME_RE = /^[a-zA-Z0-9.\-_]+$/;
+function validateComponentName(name, existing) {
+  const trimmed = name.trim();
+  if (!trimmed) return "Name is required";
+  if (!COMPONENT_NAME_RE.test(trimmed)) {
+    return 'Only letters, digits, ".", "-" and "_" are allowed';
+  }
+  if (existing.includes(trimmed)) return `"${trimmed}" already exists`;
+  return null;
+}
+
+// src/schema/preview-utils.ts
+function createRefResolver(spec, sharedSpec) {
+  return (ref) => {
+    if (ref.startsWith("#/")) return resolvePointer(spec, ref);
+    if (isSharedRef(ref) && sharedSpec) {
+      return resolvePointer(sharedSpec, ref.slice(SHARED_SLUG.length));
+    }
+    return void 0;
+  };
+}
+function humanTypeLabel(schema, resolve) {
+  if (!schema || typeof schema !== "object") return "any";
+  if (isRef(schema)) return refName(schema.$ref);
+  const s = schema;
+  const kw = compositeKeyword(s);
+  if (kw) return kw === "allOf" ? "all of" : kw === "oneOf" ? "one of" : "any of";
+  const kind = schemaKind(s);
+  let label;
+  if (kind === "array") {
+    const items = s.items;
+    const inner = humanTypeLabel(items, resolve);
+    const plural = /^(string|integer|number|boolean|object)$/.test(inner) ? `${inner}s` : inner;
+    label = `array of ${plural}`;
+  } else if (Array.isArray(s.enum)) {
+    label = `enum<${s.type ?? "string"}>`;
+  } else {
+    label = s.type ?? "object";
+  }
+  if (s.nullable) label += " | null";
+  return label;
+}
+function resolveChildren(schema, resolve, seen = /* @__PURE__ */ new Set()) {
+  if (!schema || typeof schema !== "object") return { fields: [], seen };
+  if (isRef(schema)) {
+    if (!resolve || seen.has(schema.$ref)) return { fields: [], seen };
+    const target = resolve(schema.$ref);
+    if (!target) return { fields: [], seen };
+    return resolveChildren(target, resolve, /* @__PURE__ */ new Set([...seen, schema.$ref]));
+  }
+  const s = schema;
+  const kw = compositeKeyword(s);
+  if (kw) {
+    const fields = (s[kw] ?? []).map((branch, i) => ({
+      name: isRef(branch) ? refName(branch.$ref) : `option ${i + 1}`,
+      schema: branch,
+      required: false
+    }));
+    return { fields, seen };
+  }
+  const kind = schemaKind(s);
+  if (kind === "array") return resolveChildren(s.items, resolve, seen);
+  if (kind === "object") {
+    const props = s.properties ?? {};
+    const required = s.required ?? [];
+    const fields = Object.entries(props).map(([name, child]) => ({
+      name,
+      schema: child,
+      required: required.includes(name)
+    }));
+    return { fields, seen };
+  }
+  return { fields: [], seen };
+}
+function childFields(schema, resolve, seen = /* @__PURE__ */ new Set()) {
+  return resolveChildren(schema, resolve, seen).fields;
+}
+function hasChildren(schema, resolve, seen = /* @__PURE__ */ new Set()) {
+  return resolveChildren(schema, resolve, seen).fields.length > 0;
+}
+
+export {
+  SCHEMA_TYPE_OPTIONS,
+  COMPOSITE_KEYWORDS,
+  isRef,
+  compositeKeyword,
+  schemaKind,
+  schemaTypeLabel,
+  refName,
+  createSchemaForType,
+  createCompositeSchema,
+  createRefSchema,
+  applyPatch,
+  renameKey,
+  uniqueKey,
+  insertKeyAt,
+  moveKey,
+  SHARED_SLUG,
+  extractRefOptions,
+  extractSharedRefOptions,
+  isSharedRef,
+  buildSharedRef,
+  walkRefs,
+  resolvePointer,
+  findDanglingRefs,
+  componentSkeleton,
+  COMPONENT_NAME_RE,
+  validateComponentName,
+  createRefResolver,
+  humanTypeLabel,
+  resolveChildren,
+  childFields,
+  hasChildren
+};

package/dist/index.d.ts

@@ -0,0 +1,84 @@
+import { SchemaOrRef, RefResolver } from './schema/index.js';
+export { COMPONENT_NAME_RE, COMPOSITE_KEYWORDS, ChildField, CompositeKeyword, FoundRef, RefObject, ResolvedChildren, SCHEMA_TYPE_OPTIONS, SHARED_SLUG, SchemaKind, SchemaObject, SchemaType, applyPatch, buildSharedRef, childFields, componentSkeleton, compositeKeyword, createCompositeSchema, createRefResolver, createRefSchema, createSchemaForType, extractRefOptions, extractSharedRefOptions, findDanglingRefs, hasChildren, humanTypeLabel, insertKeyAt, isRef, isSharedRef, moveKey, refName, renameKey, resolveChildren, resolvePointer, schemaKind, schemaTypeLabel, uniqueKey, validateComponentName, walkRefs } from './schema/index.js';
+import * as react from 'react';
+import { ClassValue } from 'clsx';
+
+interface MarkdownProps {
+    children: string;
+    /** Compact variant for field-row descriptions (smaller, muted). */
+    compact?: boolean;
+    className?: string;
+}
+/**
+ * Markdown viewer for OpenAPI `description` fields (CommonMark + GFM).
+ * Raw HTML is NOT rendered (react-markdown default — safe for untrusted
+ * specs); links open in a new tab.
+ */
+declare function Markdown({ children, compact, className }: MarkdownProps): react.JSX.Element;
+
+declare function ConstraintPills({ schema }: {
+    schema: SchemaOrRef | undefined;
+}): react.JSX.Element | null;
+
+declare function SchemaFields({ schema, resolve, seen, }: {
+    schema: SchemaOrRef | undefined;
+    resolve?: RefResolver;
+    seen?: Set<string>;
+}): react.JSX.Element;
+
+interface NavOperation {
+    id: string;
+    method: string;
+    path: string;
+    label: string;
+    deprecated?: boolean;
+}
+interface NavArtifact {
+    groups: {
+        tag: string;
+        operations: NavOperation[];
+    }[];
+    schemas: string[];
+}
+interface MetaArtifact {
+    title: string;
+    description?: string;
+    specVersion: string;
+    openapi: string;
+    counts: {
+        operations: number;
+        schemas: number;
+    };
+}
+
+/**
+ * The published API reference (Stripe-style): sticky sidebar (tag >
+ * operations + schemas) and one long document — operation sections with
+ * parameters / request body / responses, then a schema section. A client
+ * component because SchemaFields expands refs through a resolver function;
+ * Next still server-renders it to HTML, which is what SEO needs.
+ *
+ * Phase 1 renders from the full publication spec; page-level chunking is a
+ * follow-up (portal.md, deferred list).
+ */
+type AnyRecord = Record<string, unknown>;
+declare function MethodBadge({ method, small }: {
+    method: string;
+    small?: boolean;
+}): react.JSX.Element;
+declare function OperationSection({ spec, id, method, path, resolve, }: {
+    spec: AnyRecord;
+    id: string;
+    method: string;
+    path: string;
+    resolve: RefResolver;
+}): react.JSX.Element | null;
+declare function ApiReference({ spec, nav, meta, }: {
+    spec: AnyRecord;
+    nav: NavArtifact;
+    meta: MetaArtifact;
+}): react.JSX.Element;
+
+declare function cn(...inputs: ClassValue[]): string;
+
+export { ApiReference, ConstraintPills, Markdown, type MarkdownProps, type MetaArtifact, MethodBadge, type NavArtifact, type NavOperation, OperationSection, RefResolver, SchemaFields, SchemaOrRef, cn };

package/dist/index.js

@@ -0,0 +1,449 @@
+import {
+  COMPONENT_NAME_RE,
+  COMPOSITE_KEYWORDS,
+  SCHEMA_TYPE_OPTIONS,
+  SHARED_SLUG,
+  applyPatch,
+  buildSharedRef,
+  childFields,
+  componentSkeleton,
+  compositeKeyword,
+  createCompositeSchema,
+  createRefResolver,
+  createRefSchema,
+  createSchemaForType,
+  extractRefOptions,
+  extractSharedRefOptions,
+  findDanglingRefs,
+  hasChildren,
+  humanTypeLabel,
+  insertKeyAt,
+  isRef,
+  isSharedRef,
+  moveKey,
+  refName,
+  renameKey,
+  resolveChildren,
+  resolvePointer,
+  schemaKind,
+  schemaTypeLabel,
+  uniqueKey,
+  validateComponentName,
+  walkRefs
+} from "./chunk-WO4ZCICV.js";
+
+// src/components/markdown.tsx
+import ReactMarkdown from "react-markdown";
+import remarkGfm from "remark-gfm";
+
+// src/cn.ts
+import { clsx } from "clsx";
+import { twMerge } from "tailwind-merge";
+function cn(...inputs) {
+  return twMerge(clsx(inputs));
+}
+
+// src/components/markdown.tsx
+import { jsx } from "react/jsx-runtime";
+function Markdown({ children, compact, className }) {
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      className: cn(
+        "prose prose-sm max-w-none dark:prose-invert",
+        // tighten spacing for inline-doc contexts
+        "prose-p:my-1 prose-ul:my-1 prose-ol:my-1 prose-li:my-0 prose-headings:mb-1 prose-headings:mt-2",
+        "prose-pre:my-2 prose-pre:rounded-md prose-pre:bg-muted prose-pre:p-3 prose-pre:text-foreground",
+        "prose-code:rounded prose-code:bg-muted prose-code:px-1 prose-code:py-px prose-code:font-mono",
+        "prose-code:before:content-none prose-code:after:content-none",
+        "prose-table:my-2 prose-th:px-2 prose-th:py-1 prose-td:px-2 prose-td:py-1",
+        compact && "text-[13px] leading-snug text-muted-foreground prose-code:text-xs",
+        className
+      ),
+      children: /* @__PURE__ */ jsx(
+        ReactMarkdown,
+        {
+          remarkPlugins: [remarkGfm],
+          components: {
+            a: ({ href, children: kids }) => /* @__PURE__ */ jsx("a", { href, target: "_blank", rel: "noopener noreferrer", children: kids })
+          },
+          children
+        }
+      )
+    }
+  );
+}
+
+// src/components/constraint-pills.tsx
+import { jsx as jsx2, jsxs } from "react/jsx-runtime";
+function Pill({ highlight, children }) {
+  return /* @__PURE__ */ jsx2(
+    "span",
+    {
+      className: cn(
+        "inline-flex max-w-[460px] items-center gap-1 truncate rounded border px-1.5 py-px text-[11px] whitespace-nowrap",
+        highlight && "border-transparent bg-orange-600 text-white dark:bg-orange-700"
+      ),
+      children
+    }
+  );
+}
+function KV({ k, v }) {
+  return /* @__PURE__ */ jsxs(Pill, { children: [
+    /* @__PURE__ */ jsxs("span", { className: "text-muted-foreground", children: [
+      k,
+      ":"
+    ] }),
+    /* @__PURE__ */ jsx2("span", { className: "truncate font-mono", children: typeof v === "string" ? v : JSON.stringify(v) })
+  ] });
+}
+function rangeText(name, min, max, exclusiveMin, exclusiveMax) {
+  const parts = [];
+  if (min !== void 0) parts.push(`${name} ${exclusiveMin ? ">" : ">="} ${min}`);
+  if (max !== void 0) parts.push(`${name} ${exclusiveMax ? "<" : "<="} ${max}`);
+  return parts.length ? parts.join(" and ") : null;
+}
+function ConstraintPills({ schema }) {
+  if (!schema || isRef(schema)) return null;
+  const s = schema;
+  const pills = [];
+  const push = (key, node) => pills.push(/* @__PURE__ */ jsx2("span", { children: node }, key));
+  if (s.deprecated) push("deprecated", /* @__PURE__ */ jsx2(Pill, { highlight: true, children: "deprecated" }));
+  if (s["x-internal"]) push("internal", /* @__PURE__ */ jsx2(Pill, { highlight: true, children: "internal" }));
+  if (s["x-debug"]) push("debug", /* @__PURE__ */ jsx2(Pill, { highlight: true, children: "debug" }));
+  if (s.format) push("format", /* @__PURE__ */ jsx2(KV, { k: "format", v: s.format }));
+  if (Array.isArray(s.enum) && s.enum.length) {
+    push("enum", /* @__PURE__ */ jsx2(KV, { k: "enum", v: s.enum.map((v) => String(v)).join(", ") }));
+  }
+  if (s.pattern) push("pattern", /* @__PURE__ */ jsx2(KV, { k: "pattern", v: s.pattern }));
+  {
+    const r = rangeText("length", s.minLength, s.maxLength, false, false);
+    if (r) push("length", /* @__PURE__ */ jsx2(Pill, { children: r }));
+  }
+  {
+    const r = rangeText(
+      "value",
+      s.minimum,
+      s.maximum,
+      s.exclusiveMinimum === true,
+      s.exclusiveMaximum === true
+    );
+    if (r) push("range", /* @__PURE__ */ jsx2(Pill, { children: r }));
+  }
+  if (s.multipleOf !== void 0) push("multipleOf", /* @__PURE__ */ jsx2(KV, { k: "multipleOf", v: s.multipleOf }));
+  {
+    const r = rangeText("items", s.minItems, s.maxItems, false, false);
+    if (r) push("items", /* @__PURE__ */ jsx2(Pill, { children: r }));
+  }
+  if (s.uniqueItems) push("unique", /* @__PURE__ */ jsx2(Pill, { children: "uniqueItems" }));
+  if (s.title) push("title", /* @__PURE__ */ jsx2(KV, { k: "title", v: s.title }));
+  if (s.default !== void 0) push("default", /* @__PURE__ */ jsx2(KV, { k: "default", v: s.default }));
+  if (s.const !== void 0) push("const", /* @__PURE__ */ jsx2(KV, { k: "const", v: s.const }));
+  if (s.readOnly) push("readOnly", /* @__PURE__ */ jsx2(Pill, { children: "readOnly" }));
+  if (s.writeOnly) push("writeOnly", /* @__PURE__ */ jsx2(Pill, { children: "writeOnly" }));
+  if (s.example !== void 0) push("example", /* @__PURE__ */ jsx2(KV, { k: "example", v: s.example }));
+  if (!pills.length) return null;
+  return /* @__PURE__ */ jsx2("div", { className: "mt-1 flex flex-wrap items-center gap-1", children: pills });
+}
+
+// src/components/schema-fields.tsx
+import { useState } from "react";
+import { ChevronDown, ChevronRight } from "lucide-react";
+import { jsx as jsx3, jsxs as jsxs2 } from "react/jsx-runtime";
+function FieldRow({
+  name,
+  schema,
+  required,
+  resolve,
+  seen
+}) {
+  const [open, setOpen] = useState(false);
+  const expandable = hasChildren(schema, resolve, seen);
+  const description = !isRef(schema) ? schema.description : void 0;
+  return /* @__PURE__ */ jsxs2("div", { className: "border-b py-2.5 last:border-b-0", children: [
+    /* @__PURE__ */ jsxs2("div", { className: "flex flex-wrap items-baseline gap-x-2", children: [
+      /* @__PURE__ */ jsx3("span", { className: "font-mono text-[13px] font-medium", children: name }),
+      /* @__PURE__ */ jsx3("span", { className: "font-mono text-xs text-muted-foreground", children: humanTypeLabel(schema, resolve) }),
+      required && /* @__PURE__ */ jsx3("span", { className: "text-[11px] font-medium text-red-600 dark:text-red-400", children: "required" })
+    ] }),
+    description && /* @__PURE__ */ jsx3(Markdown, { compact: true, className: "mt-0.5", children: description }),
+    /* @__PURE__ */ jsx3(ConstraintPills, { schema }),
+    expandable && /* @__PURE__ */ jsxs2("div", { className: "mt-1.5", children: [
+      /* @__PURE__ */ jsxs2(
+        "button",
+        {
+          type: "button",
+          onClick: () => setOpen((o) => !o),
+          className: "inline-flex items-center gap-1 rounded-full border px-2 py-0.5 text-[11px] text-muted-foreground hover:bg-accent",
+          children: [
+            open ? /* @__PURE__ */ jsx3(ChevronDown, { className: "size-3" }) : /* @__PURE__ */ jsx3(ChevronRight, { className: "size-3" }),
+            open ? "Hide child attributes" : "Show child attributes"
+          ]
+        }
+      ),
+      open && /* @__PURE__ */ jsx3("div", { className: "ml-1.5 mt-1.5 border-l pl-3", children: /* @__PURE__ */ jsx3(SchemaFields, { schema, resolve, seen }) })
+    ] })
+  ] });
+}
+function SchemaFields({
+  schema,
+  resolve,
+  seen = /* @__PURE__ */ new Set()
+}) {
+  const { fields, seen: childSeen } = resolveChildren(schema, resolve, seen);
+  if (!fields.length) {
+    return /* @__PURE__ */ jsx3("p", { className: "py-1 text-xs text-muted-foreground", children: "No attributes" });
+  }
+  return /* @__PURE__ */ jsx3("div", { children: fields.map((f) => /* @__PURE__ */ jsx3(
+    FieldRow,
+    {
+      name: f.name,
+      schema: f.schema,
+      required: f.required,
+      resolve,
+      seen: childSeen
+    },
+    f.name
+  )) });
+}
+
+// src/components/api-reference.tsx
+import { Fragment, jsx as jsx4, jsxs as jsxs3 } from "react/jsx-runtime";
+var METHOD_COLOR = {
+  GET: "bg-emerald-600",
+  POST: "bg-sky-600",
+  PUT: "bg-amber-600",
+  PATCH: "bg-orange-600",
+  DELETE: "bg-red-600",
+  HEAD: "bg-slate-500",
+  OPTIONS: "bg-slate-500",
+  TRACE: "bg-slate-500"
+};
+function MethodBadge({ method, small }) {
+  return /* @__PURE__ */ jsx4(
+    "span",
+    {
+      className: `inline-flex items-center justify-center rounded font-mono font-semibold text-white ${METHOD_COLOR[method] ?? "bg-slate-500"} ${small ? "px-1 py-px text-[9px]" : "px-1.5 py-0.5 text-[11px]"}`,
+      children: method
+    }
+  );
+}
+function deref(spec, node) {
+  let current = node;
+  for (let hops = 0; hops < 8; hops++) {
+    if (!current || typeof current !== "object") break;
+    const ref = current.$ref;
+    if (typeof ref !== "string" || !ref.startsWith("#/")) break;
+    current = resolvePointer(spec, ref);
+  }
+  return current;
+}
+function pickContent(content) {
+  if (!content || typeof content !== "object") return null;
+  const entries = Object.entries(content);
+  if (!entries.length) return null;
+  const [mediaType, body] = entries.find(([k]) => k.includes("json")) ?? entries[0];
+  const schema = body?.schema;
+  return { mediaType, schema };
+}
+function ParameterRows({
+  spec,
+  parameters,
+  resolve
+}) {
+  return /* @__PURE__ */ jsx4("div", { className: "divide-y rounded-md border", children: parameters.map((raw, i) => {
+    const p = deref(spec, raw);
+    if (!p || typeof p !== "object") return null;
+    const schema = p.schema;
+    return /* @__PURE__ */ jsxs3("div", { className: "px-3 py-2", children: [
+      /* @__PURE__ */ jsxs3("div", { className: "flex flex-wrap items-baseline gap-2", children: [
+        /* @__PURE__ */ jsx4("code", { className: "font-mono text-[13px] font-semibold", children: String(p.name ?? "") }),
+        /* @__PURE__ */ jsx4("span", { className: "text-xs text-muted-foreground", children: String(p.in ?? "") }),
+        /* @__PURE__ */ jsx4("span", { className: "text-xs text-muted-foreground", children: humanTypeLabel(schema, resolve) }),
+        p.required === true && /* @__PURE__ */ jsx4("span", { className: "text-[11px] font-medium text-red-600", children: "required" }),
+        p.deprecated === true && /* @__PURE__ */ jsx4("span", { className: "text-[11px] font-medium text-orange-600", children: "deprecated" })
+      ] }),
+      /* @__PURE__ */ jsx4(ConstraintPills, { schema }),
+      typeof p.description === "string" && p.description && /* @__PURE__ */ jsx4(Markdown, { compact: true, children: p.description })
+    ] }, i);
+  }) });
+}
+function SectionLabel({ children }) {
+  return /* @__PURE__ */ jsx4("h4", { className: "mb-2 mt-5 text-[11px] font-semibold uppercase tracking-wider text-muted-foreground", children });
+}
+function OperationSection({
+  spec,
+  id,
+  method,
+  path,
+  resolve
+}) {
+  const op = spec.paths?.[path]?.[method.toLowerCase()];
+  if (!op) return null;
+  const pathItem = spec.paths?.[path];
+  const parameters = [
+    ...Array.isArray(pathItem?.parameters) ? pathItem.parameters : [],
+    ...Array.isArray(op.parameters) ? op.parameters : []
+  ];
+  const requestBody = op.requestBody ? deref(spec, op.requestBody) : null;
+  const requestContent = requestBody ? pickContent(requestBody.content) : null;
+  const responses = Object.entries(op.responses ?? {});
+  return /* @__PURE__ */ jsxs3("section", { id, className: "scroll-mt-20 border-t py-8 first:border-t-0", children: [
+    /* @__PURE__ */ jsxs3("h3", { className: "text-lg font-semibold", children: [
+      typeof op.summary === "string" && op.summary ? op.summary : typeof op.operationId === "string" && op.operationId ? op.operationId : `${method} ${path}`,
+      op.deprecated === true && /* @__PURE__ */ jsx4("span", { className: "ml-2 align-middle text-xs font-medium text-orange-600", children: "deprecated" })
+    ] }),
+    /* @__PURE__ */ jsxs3("div", { className: "mt-2 flex items-center gap-2", children: [
+      /* @__PURE__ */ jsx4(MethodBadge, { method }),
+      /* @__PURE__ */ jsx4("code", { className: "font-mono text-[13px]", children: path })
+    ] }),
+    typeof op.description === "string" && op.description && /* @__PURE__ */ jsx4("div", { className: "mt-3", children: /* @__PURE__ */ jsx4(Markdown, { children: op.description }) }),
+    parameters.length > 0 && /* @__PURE__ */ jsxs3(Fragment, { children: [
+      /* @__PURE__ */ jsx4(SectionLabel, { children: "Parameters" }),
+      /* @__PURE__ */ jsx4(ParameterRows, { spec, parameters, resolve })
+    ] }),
+    requestContent && /* @__PURE__ */ jsxs3(Fragment, { children: [
+      /* @__PURE__ */ jsxs3(SectionLabel, { children: [
+        "Request body",
+        " ",
+        /* @__PURE__ */ jsx4("span", { className: "font-mono font-normal normal-case", children: requestContent.mediaType })
+      ] }),
+      typeof requestBody?.description === "string" && requestBody.description && /* @__PURE__ */ jsx4(Markdown, { compact: true, children: requestBody.description }),
+      /* @__PURE__ */ jsx4("div", { className: "rounded-md border px-3 py-1", children: /* @__PURE__ */ jsx4(SchemaFields, { schema: requestContent.schema, resolve }) })
+    ] }),
+    responses.length > 0 && /* @__PURE__ */ jsxs3(Fragment, { children: [
+      /* @__PURE__ */ jsx4(SectionLabel, { children: "Responses" }),
+      /* @__PURE__ */ jsx4("div", { className: "space-y-3", children: responses.map(([status, raw]) => {
+        const res = deref(spec, raw);
+        if (!res || typeof res !== "object") return null;
+        const content = pickContent(res.content);
+        return /* @__PURE__ */ jsxs3("div", { className: "rounded-md border", children: [
+          /* @__PURE__ */ jsxs3("div", { className: "flex items-baseline gap-2 border-b bg-muted/50 px-3 py-1.5", children: [
+            /* @__PURE__ */ jsx4("code", { className: "font-mono text-[13px] font-semibold", children: status }),
+            typeof res.description === "string" && res.description && /* @__PURE__ */ jsx4("span", { className: "text-xs text-muted-foreground", children: res.description })
+          ] }),
+          content?.schema ? /* @__PURE__ */ jsx4("div", { className: "px-3 py-1", children: /* @__PURE__ */ jsx4(SchemaFields, { schema: content.schema, resolve }) }) : /* @__PURE__ */ jsx4("p", { className: "px-3 py-2 text-xs text-muted-foreground", children: "No content" })
+        ] }, status);
+      }) })
+    ] })
+  ] });
+}
+function ApiReference({
+  spec,
+  nav,
+  meta
+}) {
+  const resolve = createRefResolver(spec, null);
+  const schemas = spec.components?.schemas ?? {};
+  return /* @__PURE__ */ jsxs3("div", { className: "mx-auto flex max-w-6xl gap-10 px-6", children: [
+    /* @__PURE__ */ jsxs3("aside", { className: "sticky top-0 hidden h-screen w-60 shrink-0 overflow-y-auto py-10 md:block", children: [
+      /* @__PURE__ */ jsx4("p", { className: "truncate text-sm font-semibold", children: meta.title }),
+      /* @__PURE__ */ jsx4("p", { className: "font-mono text-xs text-muted-foreground", children: meta.specVersion }),
+      /* @__PURE__ */ jsxs3("nav", { className: "mt-6 space-y-5", children: [
+        nav.groups.map((group) => /* @__PURE__ */ jsxs3("div", { children: [
+          /* @__PURE__ */ jsx4("p", { className: "mb-1 text-[11px] font-semibold uppercase tracking-wider text-muted-foreground", children: group.tag }),
+          /* @__PURE__ */ jsx4("ul", { children: group.operations.map((op) => /* @__PURE__ */ jsx4("li", { children: /* @__PURE__ */ jsxs3(
+            "a",
+            {
+              href: `#${op.id}`,
+              className: "flex items-center gap-1.5 rounded px-1 py-0.5 text-[13px] hover:bg-accent",
+              children: [
+                /* @__PURE__ */ jsx4(MethodBadge, { method: op.method, small: true }),
+                /* @__PURE__ */ jsx4("span", { className: `truncate ${op.deprecated ? "line-through opacity-60" : ""}`, children: op.label })
+              ]
+            }
+          ) }, op.id)) })
+        ] }, group.tag)),
+        nav.schemas.length > 0 && /* @__PURE__ */ jsxs3("div", { children: [
+          /* @__PURE__ */ jsx4("p", { className: "mb-1 text-[11px] font-semibold uppercase tracking-wider text-muted-foreground", children: "Schemas" }),
+          /* @__PURE__ */ jsx4("ul", { children: nav.schemas.map((name) => /* @__PURE__ */ jsx4("li", { children: /* @__PURE__ */ jsx4(
+            "a",
+            {
+              href: `#schema-${name}`,
+              className: "block truncate rounded px-1 py-0.5 font-mono text-[13px] hover:bg-accent",
+              children: name
+            }
+          ) }, name)) })
+        ] })
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxs3("main", { className: "min-w-0 flex-1 py-10", children: [
+      /* @__PURE__ */ jsxs3("header", { className: "pb-6", children: [
+        /* @__PURE__ */ jsx4("h1", { className: "text-3xl font-semibold", children: meta.title }),
+        /* @__PURE__ */ jsxs3("p", { className: "mt-1 font-mono text-xs text-muted-foreground", children: [
+          "v",
+          meta.specVersion,
+          " \xB7 OpenAPI ",
+          meta.openapi
+        ] }),
+        meta.description && /* @__PURE__ */ jsx4("div", { className: "mt-4", children: /* @__PURE__ */ jsx4(Markdown, { children: meta.description }) })
+      ] }),
+      nav.groups.map((group) => /* @__PURE__ */ jsxs3("div", { children: [
+        /* @__PURE__ */ jsx4("h2", { className: "mt-10 border-b pb-2 text-xl font-semibold", children: group.tag }),
+        group.operations.map((op) => /* @__PURE__ */ jsx4(
+          OperationSection,
+          {
+            spec,
+            id: op.id,
+            method: op.method,
+            path: op.path,
+            resolve
+          },
+          op.id
+        ))
+      ] }, group.tag)),
+      nav.schemas.length > 0 && /* @__PURE__ */ jsxs3("div", { children: [
+        /* @__PURE__ */ jsx4("h2", { className: "mt-10 border-b pb-2 text-xl font-semibold", children: "Schemas" }),
+        nav.schemas.map((name) => {
+          const schema = schemas[name];
+          return /* @__PURE__ */ jsxs3("section", { id: `schema-${name}`, className: "scroll-mt-20 border-t py-6 first:border-t-0", children: [
+            /* @__PURE__ */ jsx4("h3", { className: "font-mono text-base font-semibold", children: name }),
+            !isRef(schema) && typeof schema?.description === "string" && schema.description && /* @__PURE__ */ jsx4(Markdown, { compact: true, children: schema.description }),
+            /* @__PURE__ */ jsx4(ConstraintPills, { schema }),
+            /* @__PURE__ */ jsx4("div", { className: "mt-2 rounded-md border px-3 py-1", children: /* @__PURE__ */ jsx4(SchemaFields, { schema, resolve }) })
+          ] }, name);
+        })
+      ] })
+    ] })
+  ] });
+}
+export {
+  ApiReference,
+  COMPONENT_NAME_RE,
+  COMPOSITE_KEYWORDS,
+  ConstraintPills,
+  Markdown,
+  MethodBadge,
+  OperationSection,
+  SCHEMA_TYPE_OPTIONS,
+  SHARED_SLUG,
+  SchemaFields,
+  applyPatch,
+  buildSharedRef,
+  childFields,
+  cn,
+  componentSkeleton,
+  compositeKeyword,
+  createCompositeSchema,
+  createRefResolver,
+  createRefSchema,
+  createSchemaForType,
+  extractRefOptions,
+  extractSharedRefOptions,
+  findDanglingRefs,
+  hasChildren,
+  humanTypeLabel,
+  insertKeyAt,
+  isRef,
+  isSharedRef,
+  moveKey,
+  refName,
+  renameKey,
+  resolveChildren,
+  resolvePointer,
+  schemaKind,
+  schemaTypeLabel,
+  uniqueKey,
+  validateComponentName,
+  walkRefs
+};

package/dist/schema/index.d.ts

@@ -0,0 +1,165 @@
+/**
+ * OpenAPI 3.x Schema Object — the editor's working type.
+ *
+ * document-centric: this IS the plain spec object (no internal model).
+ * `$ref` nodes are `{ $ref: '#/components/schemas/X' }`.
+ */
+interface RefObject {
+    $ref: string;
+    [key: string]: unknown;
+}
+type SchemaType = 'object' | 'array' | 'string' | 'number' | 'integer' | 'boolean' | 'null';
+interface SchemaObject {
+    type?: SchemaType;
+    properties?: Record<string, SchemaOrRef>;
+    required?: string[];
+    additionalProperties?: boolean | SchemaOrRef;
+    items?: SchemaOrRef;
+    minItems?: number;
+    maxItems?: number;
+    uniqueItems?: boolean;
+    allOf?: SchemaOrRef[];
+    oneOf?: SchemaOrRef[];
+    anyOf?: SchemaOrRef[];
+    not?: SchemaOrRef;
+    format?: string;
+    pattern?: string;
+    minLength?: number;
+    maxLength?: number;
+    minimum?: number;
+    maximum?: number;
+    exclusiveMinimum?: boolean | number;
+    exclusiveMaximum?: boolean | number;
+    multipleOf?: number;
+    enum?: unknown[];
+    const?: unknown;
+    default?: unknown;
+    example?: unknown;
+    examples?: unknown[];
+    title?: string;
+    description?: string;
+    nullable?: boolean;
+    readOnly?: boolean;
+    writeOnly?: boolean;
+    deprecated?: boolean;
+    'x-internal'?: boolean;
+    'x-debug'?: boolean;
+    [key: string]: unknown;
+}
+type SchemaOrRef = SchemaObject | RefObject;
+/** What a node "is", driving which editor renders it. */
+type SchemaKind = 'ref' | 'object' | 'array' | 'composite' | 'enum' | 'primitive' | 'any';
+type CompositeKeyword = 'allOf' | 'oneOf' | 'anyOf';
+/** Type options offered by the TypePicker. */
+declare const SCHEMA_TYPE_OPTIONS: readonly ["object", "array", "string", "number", "integer", "boolean", "null"];
+declare const COMPOSITE_KEYWORDS: readonly ["allOf", "oneOf", "anyOf"];
+
+declare function isRef(s: SchemaOrRef | undefined | null): s is RefObject;
+declare function compositeKeyword(s: SchemaOrRef | undefined | null): CompositeKeyword | null;
+/** Classify a node — drives which node editor renders it. */
+declare function schemaKind(s: SchemaOrRef | undefined | null): SchemaKind;
+/** Short display label for a node's type (tree row, previews). */
+declare function schemaTypeLabel(s: SchemaOrRef | undefined | null): string;
+/** Last segment of a $ref, e.g. '#/components/schemas/Pet' → 'Pet'. */
+declare function refName(ref: string): string;
+
+/**
+ * Build the schema for a node whose type just changed, retaining
+ * cross-type metadata from the previous schema.
+ */
+declare function createSchemaForType(type: SchemaType, prev?: SchemaOrRef): SchemaObject;
+/** Switch a node to a composite keyword, seeding it with the previous schema when sensible. */
+declare function createCompositeSchema(keyword: 'allOf' | 'oneOf' | 'anyOf', prev?: SchemaOrRef): SchemaObject;
+/** Switch a node to a $ref (metadata cannot live on a ref; it is dropped by design). */
+declare function createRefSchema(ref: string): SchemaOrRef;
+
+/**
+ * Merge a partial edit into a schema. Keys whose patch value is `undefined`
+ * are REMOVED — so clearing a field truly deletes it from the spec
+ * (document-centric: no `minLength: undefined` noise).
+ */
+declare function applyPatch(schema: SchemaObject, patch: Partial<SchemaObject>): SchemaObject;
+
+/**
+ * Helpers for editing `properties` records. JS objects preserve insertion
+ * order, and property order matters in the editor (move up/down), so these
+ * always rebuild records order-preservingly.
+ */
+/** Rename a key, keeping its position. No-op if oldKey is missing or newKey exists. */
+declare function renameKey<T>(record: Record<string, T>, oldKey: string, newKey: string): Record<string, T>;
+/** First `base`, `base2`, `base3`… not present in the record. */
+declare function uniqueKey(record: Record<string, unknown>, base?: string): string;
+/** Insert a key at an index (clamped), preserving the order of the rest. */
+declare function insertKeyAt<T>(record: Record<string, T>, key: string, value: T, index: number): Record<string, T>;
+/** Move a key to a new index (clamped), preserving the order of the rest. */
+declare function moveKey<T>(record: Record<string, T>, key: string, toIndex: number): Record<string, T>;
+
+/** The reserved document slug for a project's shared components. */
+declare const SHARED_SLUG = "shared";
+/** All `#/components/schemas/X` pointers a TypePicker can offer, from a spec. */
+declare function extractRefOptions(spec: Record<string, unknown>): string[];
+/** Cross-document pointers into the project's shared components. */
+declare function extractSharedRefOptions(sharedSpec: Record<string, unknown>): string[];
+declare function isSharedRef(ref: string): boolean;
+declare function buildSharedRef(name: string): string;
+interface FoundRef {
+    /** JSON path of the node holding the $ref. */
+    path: (string | number)[];
+    ref: string;
+}
+/** Walk a spec and collect every `$ref` with its location. */
+declare function walkRefs(node: unknown, path?: (string | number)[], out?: FoundRef[]): FoundRef[];
+/** Resolve a JSON pointer fragment ('#/components/schemas/X') against a spec. */
+declare function resolvePointer(spec: Record<string, unknown>, pointer: string): unknown;
+/**
+ * Find dangling `$ref`s: local refs are resolved against the spec itself,
+ * `shared#/…` refs against the shared spec. Anything else is left alone
+ * (external URLs etc. are not our business here).
+ */
+declare function findDanglingRefs(spec: Record<string, unknown>, sharedSpec: Record<string, unknown> | null): FoundRef[];
+
+/**
+ * Default (standard-OpenAPI) skeletons for newly created components — the
+ * modern counterpart of the old editor's `defaultDefinition`.
+ */
+declare function componentSkeleton(typeKey: string, name: string): Record<string, unknown>;
+/** OpenAPI component-key rule: ^[a-zA-Z0-9.\-_]+$ */
+declare const COMPONENT_NAME_RE: RegExp;
+declare function validateComponentName(name: string, existing: string[]): string | null;
+
+type RefResolver = (ref: string) => SchemaOrRef | undefined;
+/**
+ * Resolver over the current spec + the project's shared spec — used by the
+ * Stripe-style preview to expand `$ref`s inline.
+ */
+declare function createRefResolver(spec: Record<string, unknown>, sharedSpec: Record<string, unknown> | null): RefResolver;
+/**
+ * Stripe-style human type label: 'string', 'integer', 'object',
+ * 'array of strings', 'array of Pet', 'enum<string>', 'one of', 'Pet'…
+ * Nullable is appended as ' | null' (kept subtle by the renderer).
+ */
+declare function humanTypeLabel(schema: SchemaOrRef | undefined, resolve?: RefResolver): string;
+interface ChildField {
+    name: string;
+    schema: SchemaOrRef;
+    required: boolean;
+}
+interface ResolvedChildren {
+    fields: ChildField[];
+    /** `seen` accumulated through any $refs crossed while resolving — thread
+     * this to the child rows so circular refs stop expanding. */
+    seen: Set<string>;
+}
+/**
+ * The expandable children of a node, Stripe-style:
+ * - object → its properties
+ * - array → its items' children (arrays expand straight into the item shape)
+ * - composite → each branch as a pseudo-field
+ * - $ref → children of the resolved target (ref recorded into `seen`)
+ */
+declare function resolveChildren(schema: SchemaOrRef | undefined, resolve: RefResolver | undefined, seen?: Set<string>): ResolvedChildren;
+declare function childFields(schema: SchemaOrRef | undefined, resolve: RefResolver | undefined, seen?: Set<string>): ChildField[];
+/** Whether the preview should offer a "Show child attributes" expander. */
+declare function hasChildren(schema: SchemaOrRef | undefined, resolve: RefResolver | undefined, seen?: Set<string>): boolean;
+
+export { COMPONENT_NAME_RE, COMPOSITE_KEYWORDS, type ChildField, type CompositeKeyword, type FoundRef, type RefObject, type RefResolver, type ResolvedChildren, SCHEMA_TYPE_OPTIONS, SHARED_SLUG, type SchemaKind, type SchemaObject, type SchemaOrRef, type SchemaType, applyPatch, buildSharedRef, childFields, componentSkeleton, compositeKeyword, createCompositeSchema, createRefResolver, createRefSchema, createSchemaForType, extractRefOptions, extractSharedRefOptions, findDanglingRefs, hasChildren, humanTypeLabel, insertKeyAt, isRef, isSharedRef, moveKey, refName, renameKey, resolveChildren, resolvePointer, schemaKind, schemaTypeLabel, uniqueKey, validateComponentName, walkRefs };

package/dist/schema/index.js

@@ -0,0 +1,66 @@
+import {
+  COMPONENT_NAME_RE,
+  COMPOSITE_KEYWORDS,
+  SCHEMA_TYPE_OPTIONS,
+  SHARED_SLUG,
+  applyPatch,
+  buildSharedRef,
+  childFields,
+  componentSkeleton,
+  compositeKeyword,
+  createCompositeSchema,
+  createRefResolver,
+  createRefSchema,
+  createSchemaForType,
+  extractRefOptions,
+  extractSharedRefOptions,
+  findDanglingRefs,
+  hasChildren,
+  humanTypeLabel,
+  insertKeyAt,
+  isRef,
+  isSharedRef,
+  moveKey,
+  refName,
+  renameKey,
+  resolveChildren,
+  resolvePointer,
+  schemaKind,
+  schemaTypeLabel,
+  uniqueKey,
+  validateComponentName,
+  walkRefs
+} from "../chunk-WO4ZCICV.js";
+export {
+  COMPONENT_NAME_RE,
+  COMPOSITE_KEYWORDS,
+  SCHEMA_TYPE_OPTIONS,
+  SHARED_SLUG,
+  applyPatch,
+  buildSharedRef,
+  childFields,
+  componentSkeleton,
+  compositeKeyword,
+  createCompositeSchema,
+  createRefResolver,
+  createRefSchema,
+  createSchemaForType,
+  extractRefOptions,
+  extractSharedRefOptions,
+  findDanglingRefs,
+  hasChildren,
+  humanTypeLabel,
+  insertKeyAt,
+  isRef,
+  isSharedRef,
+  moveKey,
+  refName,
+  renameKey,
+  resolveChildren,
+  resolvePointer,
+  schemaKind,
+  schemaTypeLabel,
+  uniqueKey,
+  validateComponentName,
+  walkRefs
+};

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@reapi/spec-ui",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./schema": {
+      "types": "./dist/schema/index.d.ts",
+      "default": "./dist/schema/index.js"
+    }
+  },
+  "dependencies": {
+    "clsx": "^2.1.1",
+    "lucide-react": "^0.469.0",
+    "react-markdown": "^10.1.0",
+    "remark-gfm": "^4.0.1",
+    "tailwind-merge": "^3.0.0"
+  },
+  "peerDependencies": {
+    "react": "^19.0.0"
+  },
+  "devDependencies": {
+    "@types/react": "^19.0.0",
+    "react": "^19.1.0",
+    "tsup": "^8.4.0",
+    "typescript": "^5.7.3",
+    "vitest": "^4.1.8"
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "test": "vitest --run",
+    "build": "tsup"
+  }
+}