@stapel/vocabularies-react 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,52 @@
+# @stapel/vocabularies-react
+
+## 0.1.0
+
+### Minor Changes
+
+- d1125bc: The React pair for stapel-vocabularies 0.1.0 — first release.
+
+  A ref feature carries a POINTER to a vocabulary level instead of an options
+  list, because the lists are the wrong size to inline into a category schema
+  (529 phone vendors → 14 962 models; 107 049 car modifications). The terms
+  therefore arrive over a second wire, and this package is the client for it.
+
+  **The seam, satisfied structurally.** `createVocabularyClient({ baseUrl, fetch? })`
+  returns the two functions `@stapel/attributes-react` declares as
+  `VocabularyClient` and hands to `<VocabularyClientProvider>`. Neither package
+  imports the other — in source or in `package.json` — so the two L2 pairs stay
+  independently releasable, and a host with no vocabularies module at all can
+  supply its own two functions and keep every ref editor working.
+  `test/clientShape.test.ts` holds a hand-transcribed copy of the upstream
+  interface and ASSIGNS this client to it, so a drift on either side is a red
+  build here rather than a hole a storefront finds at the composer.
+
+  It is a bare `fetch` client on purpose: both endpoints are public reads
+  (`ReadOnlyOrStaff`, ETag'd on the vocabulary revision, no session), and
+  anything needing React context could not be passed to a `value` prop at a
+  container's composition root, which is the one call site the seam exists for.
+  `parent` is OMITTED rather than sent empty (`parent=` asks for the children of
+  a term whose code is the empty string); `resolve` splits at 200 codes, because
+  the server ignores the tail of a longer list instead of refusing it; a refusal
+  folds into core's one dialect and an abort is rethrown AS an abort, so a
+  superseded keystroke never looks like a dead backend.
+
+  **Hooks.** `useTermSearch` debounces 250 ms, aborts what it supersedes, fetches
+  the first page immediately on open (once per level and parent — antd reports a
+  dropdown as opening on every keystroke) and empties itself when the parent
+  moves. It is deliberately not a query. `useTermLabels` is: the same codes give
+  the same labels until the vocabulary's revision moves, so it is keyed through
+  `vocabulariesQueryKeys` and hands out a `LoadState` rather than a bare map —
+  `{}` would say "these codes have no labels" in the same words as "nobody has
+  asked yet".
+
+  **`/default` `<VocabularyTermSelect>`.** The same control the `ref_select`
+  editor draws, shipped on its own for the places a composer is not: a facet
+  filter, an admin form, a bulk-edit row. `filterOption={false}` — the options
+  ARE the answer to the current query. A held code is resolved to its label and
+  stays pickable even when the current page does not contain it. No client is a
+  LOUD state: the notice, not an empty dropdown.
+
+  Ships en/ru/es. No nav entry and no overview screen: this pair ships a control
+  other pairs' forms mount, not a destination (the `@stapel/attributes-react`
+  precedent).

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Stapel contributors
+
+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/MODULE.md

@@ -0,0 +1,92 @@
+# @stapel/vocabularies-react — module guide
+
+The React pair for **stapel-vocabularies**. Human companion to the generated
+`llms.txt` (agent context) and `manifest.json` (machine catalog); `README.md` is
+the usage entry point.
+
+## What this pair is for
+
+One sentence: **a ref feature points at a vocabulary level instead of carrying
+options, and this is how the terms get to the browser.**
+
+Everything below follows from the sizes. A category schema that inlined 14 962
+phone models would be a response nobody can cache and a form nobody can open, so
+`stapel-attributes` 0.5 made `ref_select` / `ref_hierarchical_select` carry a
+pointer, and the terms travel on their own wire. That wire has exactly two reads
+a form needs — search a level, resolve some codes — and they are the whole
+public surface of this package.
+
+## Layers
+
+- **client.ts** — `createVocabularyClient({ baseUrl, fetch?, limit? })`. A bare
+  `fetch` client on purpose: the seam it satisfies is two async functions that a
+  container hands to a React *value* prop, so anything requiring context could
+  not be passed at all. Both endpoints are public reads (`ReadOnlyOrStaff`,
+  ETag'd on the vocabulary revision, no session), so there is no token to carry;
+  a host that needs headers passes its own `fetch`. Refusals are folded into
+  core's one dialect (`toStapelApiError`) at the single rethrow point — except
+  an abort, which is rethrown as itself, because a superseded keystroke folded
+  into an API error looks exactly like a dead backend.
+- **api/** — `createVocabulariesApi(client)` plus type aliases over the
+  package-LOCAL generated `components["schemas"]` (`Vocabulary`, `Level`,
+  `Term`, `TermPage`), produced by `pnpm gen:api` from stapel-vocabularies's own
+  `docs/schema.json`. Never parallel hand-written bodies.
+- **model/** — `useTermSearch` (debounced, superseding, parent-scoped),
+  `useTermLabels` (a TanStack query keyed through `vocabulariesQueryKeys`,
+  handing out a `LoadState`), `termLabel`, and the standard runtime wiring.
+  The split between the two is a decision, not an accident: see README.
+- **flows/** — `toFlowError` + the zero-flow `VOCABULARIES_FLOWS` shim. The
+  module annotates no `@flow_step` and its `docs/flows.json` is literally `[]`
+  (the stapel-categories precedent), so there is no machine here and none is
+  pending.
+- **headless/** — `<VocabulariesProvider>`, the standard runtime context. Not
+  needed by the seam client; needed to reach the catalogue endpoints through
+  this pair's `StapelClient`.
+- **default/** — `<VocabularyTermSelect/>`, the antd control, on the opt-in
+  `./default` subpath.
+- **i18n/** — `VOCABULARIES_I18N_KEYS` + en/ru/es. The generated backend error
+  bundles are merged in so every `error.*` code has a fallback; the three codes
+  stapel-vocabularies owns are authored by hand until upstream ships a
+  `translations/` directory.
+
+## Extension seams (frontend-standard §7)
+
+- **The vocabulary seam itself.** `VocabularyClient` is declared by
+  `@stapel/attributes-react` and satisfied here STRUCTURALLY — no import in
+  either direction, in source or in `package.json`, asserted by
+  `test/clientShape.test.ts`. A host may replace this implementation entirely
+  with its own two functions.
+- **Transport.** `createVocabularyClient({ fetch })` takes a host's own
+  instrumented/authenticated `fetch`.
+- **The control.** A host that draws its own can use `useTermSearch` /
+  `useTermLabels` and never import `./default`.
+- Client injection for the standard layers is via `<VocabulariesProvider>` /
+  core's `StapelConfigProvider` per-module override, as in every pair.
+
+## Deliberately absent
+
+- **A nav entry and an overview screen.** This pair ships a control that other
+  pairs' forms mount, not a destination — the same shape as
+  `@stapel/attributes-react`, `@stapel/cdn-react` and `@stapel/geo-react`. The
+  scaffold's placeholder panel was removed rather than shipped: a menu item
+  leading to a card that says "nothing here yet" is a promise the package does
+  not keep.
+- **A cascading control.** `ref_hierarchical_select` is drawn by
+  `@stapel/attributes-react`'s own `Cascader` editor, which reads its columns
+  from the feature's `levels`. Duplicating it here would be a second answer to
+  one question.
+- **Vocabulary administration.** Loading and editing vocabularies is
+  `manage.py load_vocabulary` and Django admin — data plumbing over reviewed
+  fixtures, not a screen.
+
+## Wire contract read here
+
+| Verb | Path | Used by |
+|---|---|---|
+| GET | `vocabularies/{slug}/terms/?level=&parent=&q=&limit=&offset=` | `client.search`, `useTermSearch` |
+| GET | `vocabularies/{slug}/terms/resolve/?level=&codes=` | `client.resolve`, `useTermLabels` |
+| GET | `vocabularies/`, `vocabularies/{slug}/` | typed in `api/types.ts`; no hook yet |
+
+Errors this pair can surface: `error.404.vocabularies_vocabulary_not_found`,
+`error.404.vocabularies_level_not_found`, `error.400.vocabularies_bad_parent`,
+plus the 42 cross-cutting `stapel_core` codes.

package/README.md

@@ -0,0 +1,173 @@
+# @stapel/vocabularies-react
+
+Reference vocabularies too large to inline into a category schema: term
+typeahead and code-to-label resolve behind the `VocabularyClient` seam, plus the
+antd term select.
+
+## Why this package exists
+
+A category's feature schema carries its own options — except when it cannot. A
+phone's `Vendor` is 529 rows and its `Model` is 14 962; a car's `Modification`
+is 107 049. `stapel-attributes` 0.5 therefore added two value types,
+`ref_select` and `ref_hierarchical_select`, whose config carries a **pointer**
+(`optionsRef {vocabulary, level, parentFeature?}`) instead of a list, and
+`GET /categories/{id}/features` sends the pointer as-is.
+
+The terms then arrive over a second wire — `stapel-vocabularies` — and this
+package is the client for it.
+
+## The seam
+
+`@stapel/attributes-react` **declares** the interface; this package
+**implements** it, structurally, and neither imports the other. Two L2 pairs do
+not depend on each other, so both stay independently releasable; the container
+is what joins them:
+
+```tsx
+import { createVocabularyClient } from "@stapel/vocabularies-react";
+import { VocabularyClientProvider } from "@stapel/attributes-react";
+
+const vocabularies = createVocabularyClient({ baseUrl: "/vocabularies/api/v1/" });
+
+<VocabularyClientProvider value={vocabularies}>
+  <ListingComposerPage … />
+</VocabularyClientProvider>;
+```
+
+`test/clientShape.test.ts` holds a hand-transcribed copy of the upstream
+interface and assigns this client to it, so a drift on either side is a red
+build here rather than a hole a storefront finds.
+
+The interface is two functions and nothing else — no query client, no auth
+runtime, no provider — which is what lets a host with no vocabularies module at
+all supply its own two functions (an in-memory table, an existing search
+endpoint) and keep every ref editor working.
+
+```ts
+search(vocabulary, level, query, parent?, signal?): Promise<readonly VocabularyTerm[]>
+resolve(vocabulary, level, codes): Promise<Readonly<Record<string, string>>>
+```
+
+`search` is `GET vocabularies/{slug}/terms/?level=&parent=&q=&limit=` —
+`parent` is OMITTED, never sent empty, because `parent=` asks for the children
+of a term whose code is the empty string. `resolve` is
+`GET vocabularies/{slug}/terms/resolve/?level=&codes=`, split into batches of
+200 because the server ignores the tail of a longer list rather than refusing
+it.
+
+## Hooks
+
+```tsx
+const { terms, loading, search, open } = useTermSearch(client, {
+  vocabulary: "avito-phones",
+  level: "Model",
+  parent: vendorCode,          // undefined = the whole level
+});
+
+const labels = useTermLabels(client, { vocabulary, level, codes });
+termLabel(labels, "iphone-15-pro"); // "iPhone 15 Pro", or the code
+```
+
+`useTermSearch` debounces 250 ms, aborts the request it supersedes, fetches the
+first page immediately on open (once per level and parent), and empties itself
+when the parent moves — what is listed belongs to the previous parent's
+children. It is deliberately NOT a query: a search is superseded per keystroke
+and scoped to a dropdown that is about to close.
+
+`useTermLabels` is the opposite and IS a query, keyed through
+`vocabulariesQueryKeys.termLabels` — the same codes give the same labels until
+the vocabulary's revision moves, and several controls on one page routinely ask
+for the same set. It hands out a `LoadState`, not a bare map: `{}` would say
+"these codes have no labels" in the same words as "nobody has asked yet".
+
+## The control
+
+```tsx
+import { VocabularyTermSelect } from "@stapel/vocabularies-react/default";
+import { registerVocabulariesI18nRu } from "@stapel/vocabularies-react/i18n/ru";
+
+<VocabularyTermSelect
+  client={vocabularies}
+  vocabulary="avito-phones"
+  level="Vendor"
+  value={codes}
+  onChange={setCodes}
+/>;
+```
+
+The same control `attributes-react`'s `ref_select` editor draws, shipped on its
+own for the places a composer is not — a facet filter, an admin form, a
+bulk-edit row. `filterOption={false}`: the options ARE the answer to the current
+query, and letting antd filter them again would hide rows the server
+deliberately ranked. A code the control already holds is resolved to its label
+and stays pickable even when the current page does not contain it. **No client
+is a loud state** — the notice, not an empty dropdown: a control that cannot
+reach its terms and looks like one that found none is how a person is left
+unable to answer a question nobody told them was broken.
+
+`./default` is themed through `SkinTheme` from `@stapel/tokens-antd/skin` (one
+bridge for the whole fleet — a pair never mounts its own `ConfigProvider` and
+never defaults a theme mode). Importing the subpath is the opt-in that pulls
+`antd`; a host with its own design system keeps importing the root entry and
+draws its own control over the hooks.
+
+Locales ship as subpaths (`./i18n/ru`, `./i18n/es`) so a host carries only the
+ones it registers; `test/i18nParity.test.ts` fails the build if a key exists in
+en and not in ru/es.
+
+This pair contributes **no nav entry**: it ships a control other pairs' forms
+mount, not a screen of its own (the `@stapel/attributes-react` precedent).
+
+## Install
+
+```
+pnpm add @stapel/vocabularies-react @stapel/core @tanstack/react-query react
+```
+
+The `VocabulariesProvider` / `createVocabulariesRuntime` pair is the standard
+runtime wiring, needed only if you reach the module's other endpoints (the
+vocabulary catalogue) through this pair's `StapelClient`. The seam client above
+needs none of it.
+
+## Layers
+
+```
+src/
+  client.ts   createVocabularyClient — the seam, a bare fetch client
+  api/        typed aliases over this pair's own generated `components`
+  model/      query keys, useTermSearch, useTermLabels, runtime wiring
+  flows/      toFlowError + zero-flow registry shim (the module annotates none)
+  headless/   VocabulariesProvider
+  default/    VocabularyTermSelect (antd, opt-in subpath)
+  i18n/       translation keys + generated backend error map (en/ru/es)
+demo/         first-class demos (compiled, product-linted, smoke-rendered)
+```
+
+## Generated surfaces (drift-gated)
+
+| Surface | Path | Gate |
+|---|---|---|
+| Typed API schema | `src/api/generated/schema.ts`, from stapel-vocabularies's own `docs/schema.json` | `pnpm gen:api:check` |
+| Flow registry | none — zero-flow module (`src/flows/registry.ts` shim) | `pnpm gen:flows:check` |
+| Backend error map + en/ru/es bundles | `src/i18n/generated/` | `pnpm gen:errors:check` |
+| Typed-event registry | `src/analytics/generated/events.json` | `pnpm gen:events:check` |
+| Demos → Ladle stories | `demo/generated/` | `pnpm gen:demos:check` |
+| `manifest.json` + `llms.txt` | package root | `pnpm gen:manifest:check` |
+
+The module ships no `translations/` directory, so `gen:errors` runs with
+`ERRORS_CATALOG_DIR` pointed at stapel-core's catalogue and
+`ERRORS_LOCALE_EXEMPT_OWNERS=stapel_vocabularies`: the cross-cutting keys come
+from core in ru/es, and the module's own three are authored in `i18n/ru.ts` /
+`i18n/es.ts` until upstream localizes them.
+
+## Guardrails
+
+Linted by the shared `@stapel/eslint-plugin` flat config and the shared
+stylelint preset. Demos are first-class code: compiled by `tsconfig.demo.json`,
+linted with the product ruleset, smoke-rendered by `test/demos.test.tsx` — and
+never shipped (excluded from the `files` allowlist; proven by
+`test/prodBundlePurity.test.ts`).
+
+## License
+
+MIT

package/dist/api/extensions.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Hand-authored API surface the codegen does not (yet) cover — browser-redirect
+ * URL builders, open-redirect guards, narrow domain type-guards, header
+ * conventions. Everything that CAN be derived from schema.json belongs in the
+ * generated operations (`api/vocabulariesApi.ts`), not here.
+ */
+export {};
+//# sourceMappingURL=extensions.d.ts.map

package/dist/api/extensions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extensions.d.ts","sourceRoot":"","sources":["../../src/api/extensions.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,EAAE,CAAC"}

package/dist/api/extensions.js

@@ -0,0 +1,8 @@
+/**
+ * Hand-authored API surface the codegen does not (yet) cover — browser-redirect
+ * URL builders, open-redirect guards, narrow domain type-guards, header
+ * conventions. Everything that CAN be derived from schema.json belongs in the
+ * generated operations (`api/vocabulariesApi.ts`), not here.
+ */
+export {};
+//# sourceMappingURL=extensions.js.map

package/dist/api/extensions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"extensions.js","sourceRoot":"","sources":["../../src/api/extensions.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,EAAE,CAAC"}

package/dist/api/generated/schema.d.ts

@@ -0,0 +1,234 @@
+export interface paths {
+    "/vocabularies/api/v1/vocabularies/": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List vocabularies
+         * @description Every vocabulary this deployment holds, with its levels and revision. Cacheable: the ETag covers the highest revision and the number of vocabularies.
+         *
+         *     **Permissions:** `ReadOnlyOrStaff`
+         */
+        get: operations["vocabularies_api_v1_vocabularies_list"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/vocabularies/api/v1/vocabularies/{slug}/": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Retrieve a vocabulary
+         * @description ``GET vocabularies/{slug}/`` — one vocabulary.
+         *
+         *     **Permissions:** `ReadOnlyOrStaff`
+         */
+        get: operations["vocabularies_api_v1_vocabularies_retrieve"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/vocabularies/api/v1/vocabularies/{slug}/terms/": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Search the terms of one level
+         * @description A page of terms at `level`, optionally the children of a `parent` term at the level above, optionally matching `q`. Prefix matches rank before the rest, then the level's own sort order and label. `has_children` is what tells a cascading control whether to ask for the next level. `total` counts the whole filtered set, before limit and offset.
+         *
+         *     **Permissions:** `ReadOnlyOrStaff`
+         */
+        get: operations["vocabularies_api_v1_vocabularies_terms_retrieve"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/vocabularies/api/v1/vocabularies/{slug}/terms/resolve/": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Resolve term codes to labels
+         * @description `{code: label}` for the codes named in `codes` (comma separated, at most 200 — the rest are ignored). Unknown codes are omitted, so a caller falls back to the code, which is what a stored DAO value does when its labels are missing.
+         *
+         *     **Permissions:** `ReadOnlyOrStaff`
+         */
+        get: operations["vocabularies_api_v1_vocabularies_terms_resolve_retrieve"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+}
+export type webhooks = Record<string, never>;
+export interface components {
+    schemas: {
+        /** @description One level of a vocabulary. */
+        Level: {
+            name: string;
+            /** @description Name of the level this one hangs off; null for a root level. */
+            parent?: string | null;
+        };
+        /** @description One term of one level. */
+        Term: {
+            code: string;
+            /** @description Resolved for the request's Accept-Language when the term carries a translation, otherwise the term's own label. */
+            label: string;
+            level: string;
+            /** @description Whether this term has any child term — what tells a cascading control whether to ask for the next level. */
+            has_children: boolean;
+        };
+        /** @description One page of terms plus the size of the whole filtered set. */
+        TermPage: {
+            results: components["schemas"]["Term"][];
+            /** @description Number of terms matching level/parent/q, before limit and offset. */
+            total: number;
+        };
+        /** @description A vocabulary as the catalogue endpoints render it. */
+        Vocabulary: {
+            slug: string;
+            name: string;
+            levels: components["schemas"]["Level"][];
+            term_count: number;
+            /** @description Cache key of the whole vocabulary; also the ETag and the vocabulary.changed payload. */
+            revision: number;
+        };
+    };
+    responses: never;
+    parameters: never;
+    requestBodies: never;
+    headers: never;
+    pathItems: never;
+}
+export type $defs = Record<string, never>;
+export interface operations {
+    vocabularies_api_v1_vocabularies_list: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Vocabulary"][];
+                };
+            };
+        };
+    };
+    vocabularies_api_v1_vocabularies_retrieve: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                slug: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Vocabulary"];
+                };
+            };
+        };
+    };
+    vocabularies_api_v1_vocabularies_terms_retrieve: {
+        parameters: {
+            query: {
+                /** @description Level to list. Required. */
+                level: string;
+                /** @description Page size, 1..200 (default 50). */
+                limit?: number;
+                /** @description Rows to skip. */
+                offset?: number;
+                /** @description Code of a term at the parent level; restricts the page to its children. */
+                parent?: string;
+                /** @description Case-insensitive substring of the label. */
+                q?: string;
+            };
+            header?: never;
+            path: {
+                slug: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["TermPage"];
+                };
+            };
+        };
+    };
+    vocabularies_api_v1_vocabularies_terms_resolve_retrieve: {
+        parameters: {
+            query: {
+                /** @description Comma-separated term codes, at most 200. */
+                codes: string;
+                /** @description Level the codes belong to. Required. */
+                level: string;
+            };
+            header?: never;
+            path: {
+                slug: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        [key: string]: unknown;
+                    };
+                };
+            };
+        };
+    };
+}
+//# sourceMappingURL=schema.d.ts.map

package/dist/api/generated/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../src/api/generated/schema.ts"],"names":[],"mappings":"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"}

package/dist/api/generated/schema.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=schema.js.map

package/dist/api/generated/schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.js","sourceRoot":"","sources":["../../../src/api/generated/schema.ts"],"names":[],"mappings":""}

package/dist/api/types.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Wire types for the stapel-vocabularies HTTP contract — **derived from the generated
+ * OpenAPI surface** (frontend-standard §2/§3), never hand-maintained. The
+ * single source of truth is `components["schemas"]` from this pair's own
+ * package-LOCAL generated schema (`./generated/schema.js`, produced by
+ * `pnpm gen:api` from stapel-vocabularies's OWN `docs/schema.json` — the §17-native
+ * per-module contract). Alias the schemas this pair uses under local names
+ * here; do NOT write parallel response bodies.
+ */
+import type { components } from "./generated/schema.js";
+/** The generated schema table — the one source of truth for wire shapes. */
+export type Schemas = components["schemas"];
+/** A vocabulary as the catalogue endpoints render it. */
+export type Vocabulary = Schemas["Vocabulary"];
+/** One level of a vocabulary — `parent` names the level above, null at the root. */
+export type Level = Schemas["Level"];
+/** One term of one level. `has_children` is what tells a cascading control
+ * whether there is another column to ask for. */
+export type Term = Schemas["Term"];
+/** One page of terms plus the size of the whole filtered set (`total` counts
+ * before `limit`/`offset`, so a control can say "50 of 14 962"). */
+export type TermPage = Schemas["TermPage"];
+//# sourceMappingURL=types.d.ts.map

package/dist/api/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/api/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AAExD,4EAA4E;AAC5E,MAAM,MAAM,OAAO,GAAG,UAAU,CAAC,SAAS,CAAC,CAAC;AAE5C,yDAAyD;AACzD,MAAM,MAAM,UAAU,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;AAE/C,oFAAoF;AACpF,MAAM,MAAM,KAAK,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;AAErC;iDACiD;AACjD,MAAM,MAAM,IAAI,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;AAEnC;oEACoE;AACpE,MAAM,MAAM,QAAQ,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC"}

package/dist/api/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/api/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/api/types.ts"],"names":[],"mappings":""}