@maroonedog/luq-codegen 0.1.0

package/LICENSE

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) 2025 Luq 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/README.md

@@ -0,0 +1,258 @@
+# @maroonedog/luq-codegen
+
+Turns a JSON Schema Draft-07 schema **object** into the **source** of a
+TypeScript module that exports a Luq validator. An OpenAPI 3.0 component schema
+is that shape, so a caller that has already parsed the document can hand one
+straight in.
+
+It writes source and returns it as a string. It does not read a file, parse
+YAML, walk `paths` or `components`, or write anything to disk — the caller does
+all of that. See [the worked example](#a-worked-example).
+
+## Status
+
+- **Not published.** `npm install @maroonedog/luq-codegen` does not resolve.
+  The only way to use it today is from this checkout, with a `file:` specifier —
+  which is what [`examples/openapi`](../examples/openapi) does.
+- **It is not a plugin for `@hey-api/openapi-ts`.** The name says otherwise;
+  nothing in `src/` refers to that project, and there is no `defineConfig` or
+  plugin handler here. The name is unfinished business, not a feature.
+- **There is no CLI.** One exported function, called from your own script.
+- It imports `@maroonedog/luq/schema-tooling` — the library's own schema
+  flattener — so that the paths it writes and the paths the run-time converter
+  produces come from the same code. `peerDependencies` therefore names
+  `@maroonedog/luq` `>=2.4.0`: no earlier release carries that subpath. If the
+  subpath ships under a different number, that range moves with it.
+
+## The API
+
+```ts
+import { generateValidatorModule } from "@maroonedog/luq-codegen";
+import type { GenerateOptions, GeneratedModule } from "@maroonedog/luq-codegen";
+
+generateValidatorModule(schema: Draft07Schema, options: GenerateOptions): GeneratedModule;
+```
+
+`schema` is the Draft-07 document, already an object in memory.
+
+### `GenerateOptions`
+
+| Field | | What it is |
+|---|---|---|
+| `validatorName` | required | The name of the const to declare, e.g. `"orderValidator"`. |
+| `typeExpression` | required | Emitted verbatim inside `.for<…>()`, e.g. `'components["schemas"]["Order"]'`. |
+| `typeImport` | optional | One block of source emitted after `import { Builder }`. Omitted, the type named by `typeExpression` is assumed to be in scope already. |
+
+### `GeneratedModule`
+
+| Field | What it is |
+|---|---|
+| `source` | The whole module text: the header comment, the skipped-keyword notice, the imports, the builder chain, a trailing newline. |
+| `pluginExports` | The plugin export names used, deduplicated and sorted. Every one of them is both imported and `.use()`d in `source`, and nothing else is. |
+| `skipped` | `{ path, keyword, reason }` for every keyword that produced no rule. `path` is `""` for the root. |
+
+`ChainCall`, `FieldChain` and `SkippedKeyword` are exported as types as well.
+
+Two things are normalised, and both are pinned by tests: the keywords within one
+field are walked in sorted key order, and the plugin imports are sorted by export
+name. So the same schema object always produces the same source.
+
+**Field order is not normalised.** It follows the document's `properties` order,
+so writing the same two properties the other way round produces the same rules in
+the other order. If you diff generated output across regenerations, reorder a
+property upstream and the diff will show it.
+
+## A worked example
+
+[`examples/openapi`](../examples/openapi) is a running one — one
+`openapi.yaml`, types from `openapi-typescript`, rules from this generator,
+`npm run verify` to generate, typecheck and run it. Its README explains the
+setup; the part that concerns this package is the call:
+
+```js
+const document = parse(readFileSync(SPEC, "utf8"));
+const schema = document.components.schemas.Order;
+
+const { source, skipped } = generateValidatorModule(schema, {
+  validatorName: "orderValidator",
+  typeExpression: 'components["schemas"]["Order"]',
+});
+```
+
+The script picks the component out of the parsed document, prepends its own
+`import type { components } from "./api.generated";` line, and writes `source`
+to a file. What comes out is ordinary Luq:
+
+```ts
+export const orderValidator = Builder()
+  .use(arrayMinLengthPlugin)
+  .use(numberMinPlugin)
+  // …
+  .for<components["schemas"]["Order"]>()
+  .v("id", (b) => b.string.required().uuid())
+  .v("customer.email", (b) => b.string.required().email())
+  .v("lines", (b) => b.array.required().minLength(1))
+  .v("lines[*].quantity", (b) => b.number.required().min(1))
+  .build();
+```
+
+## What a keyword becomes
+
+| Keyword | Method | | Keyword | Method |
+|---|---|---|---|---|
+| `minLength` | `.min()` | | `maxItems` | `.maxLength()` |
+| `maxLength` | `.max()` | | `uniqueItems: true` | `.unique()` |
+| `pattern` | `.pattern()` | | `minProperties` | `.minProperties()` |
+| `minimum` | `.min()` | | `maxProperties` | `.maxProperties()` |
+| `maximum` | `.max()` | | `const` | `.literal()` |
+| `multipleOf` | `.multipleOf()` | | `enum` | `.oneOf()` |
+| `minItems` | `.minLength()` | | | |
+
+`format` values that become a method: `email`, `uuid`, `uri` (`.url()`),
+`hostname`, `ipv4`, `ipv6`, `date`, `date-time` (`.datetime()`), `time`,
+`duration`, `json-pointer` (`.jsonPointer()`), `iri`. Every other `format` is
+skipped by name.
+
+`type` chooses the slot after `b.`: `string`, `number` (also for `integer`),
+`boolean`, `array`, `object`. Anything else — no `type`, several types, `null`
+alone — falls to `any`, which checks nothing.
+
+Only the plugins actually used are imported, each from its own subpath
+(`@maroonedog/luq/plugins/uuid`, never the barrel), so the generated module
+pays for what it declares and nothing more.
+
+## Nothing is dropped in silence
+
+A keyword that cannot become a rule is returned in `skipped` **and** named in a
+comment at the top of the generated file:
+
+```
+// Keywords in this schema that did not become rules:
+//   id: type — selects the slot; it is not a method
+//   customer: properties — expands into declarations for the child fields
+//   lines: items — expands into the declaration for array elements
+//   … one line per keyword; the real block for examples/openapi has twelve
+```
+
+Most entries are structural rather than omissions: `type` chooses the slot, and
+`properties`, `items` and `required` become declarations rather than rules. The
+ones worth reading are the rest — a keyword with **no chain method** is a
+constraint the document states and the generated validator does not check.
+
+Three different things share that list, and a reader has to separate them:
+
+- **Structural** — `type`, `properties`, `items`, `required`, `$ref`. Nothing
+  was lost; these decide the slot and the shape of the declarations instead of
+  becoming rules of their own.
+- **Deliberate** — annotations (`title`, `description`, `default`, `example`,
+  `deprecated`, `readOnly`, `writeOnly`), and `uniqueItems: false`, which in
+  Draft-07 is the absence of a constraint.
+- **Unexpressed** — the reason reads `no chain method corresponds to it` or
+  `no plugin corresponds to format "…"`. This is the set to read before
+  trusting the output: the document says something the validator does not
+  check.
+
+`examples/openapi/scripts/generate.mjs` filters the first group out and prints
+what is left, which is the shape to copy in your own script.
+
+## What it does not handle
+
+A validator that quietly checks less than the document says is the failure
+worth naming, so here is everything known to be missing.
+
+**Keywords that never become a rule.** `exclusiveMinimum`, `exclusiveMaximum`,
+`oneOf`, `anyOf`, `not`, `if`/`then`/`else`, `contains`, `dependencies`,
+`propertyNames`, `patternProperties`, `additionalProperties`,
+`additionalItems`, `contentEncoding`, `contentMediaType`. Each is reported in
+`skipped`; none is checked.
+
+**`format` values outside the twelve above** — `byte`, `int64`,
+`uri-reference`, `regex`, `idn-email` and the rest. Reported by name, not
+checked.
+
+**A child-level `allOf` is dropped whole.** Only an `allOf` at the root is
+folded into the schema before flattening. On a nested schema, both its
+constraints *and* the properties it contributes disappear: the field gets a
+bare `b.any.optional()` and no declarations for the subtree. The keyword is
+listed in `skipped`, but its reason text says "folded away during flattening",
+which is true only at the root.
+
+**Tuple `items: [A, B]`** produces the array rule and no element declarations.
+
+**`nullable: true` produces no rule.** On a required field the emitted
+`.required()` rejects `null`, so the generated validator is stricter than the
+document.
+
+**`$ref` resolves only inside the object you pass.** A component schema
+containing `$ref: "#/components/schemas/Line"` makes the function **throw**,
+because there is no `components` under the root it was given. Passing the whole
+document as the root does resolve it, at the cost of a root-level declaration —
+see below. `#/definitions/…` inside a self-contained schema works.
+
+**A constraint on a slotless field emits a method that slot does not have.**
+`{ "a": { "minLength": 2 } }` — no `type` — becomes
+`.v("a", (b) => b.any.optional().min(2))`, and `min` is not on the `any` slot.
+The same happens for `enum` anywhere but a `string`, `number` or `boolean`
+field, and for any rule-bearing keyword at the **root** — an array-rooted
+schema with `minItems`, for instance, or a whole OpenAPI document handed in as
+the root — which becomes `.v("", (b) => b.any.…)`.
+
+This fails loudly rather than silently: the method is not in the slot's type,
+so the generated file does not compile.
+
+```
+error TS2339: Property 'min' does not exist on type 'FieldChain<…, "any", …>'
+```
+
+That is still a broken generation. Give the field a `type` in the document, or
+write that rule by hand.
+
+**A nested `required` is lowered only when every ancestor object is itself
+required.** In Draft-07 a subschema applies only to a value that exists, so
+`{ properties: { a: { required: ["b"] } } }` accepts `{}`. Emitting
+`.required()` on `"a.b"` would reject it and disagree with the run-time
+converter. When an ancestor is not required the generator emits `.optional()`
+instead and reports the omission in `skipped` with that reason. An array in the
+path does not break the chain: an absent array has no elements, so no element
+rule runs.
+
+## Generating, or converting at run time
+
+This package writes source you commit and read. The library can also convert a
+Draft-07 document at run time, with `fromJsonSchema` — that path handles the
+whole of Draft-07 rather than the subset above, and is the right answer when
+the document is only known at run time. See
+[docs/guide/json-schema.md](../docs/guide/json-schema.md).
+
+Generating is the right answer when the document is known now: the rules are
+plain code you can diff and step through, and they are declared against the
+generated type, so a spec change that renames a field breaks the compiler
+instead of the validator.
+
+## Working on it
+
+```bash
+npm install --ignore-scripts   # links @maroonedog/luq from the repository root
+npm run verify                 # typecheck, build, dist gates, tests
+```
+
+`npm run build` emits `dist/` with the same shape as the library: `.js` is
+CommonJS, `.mjs` is ESM, `.d.ts` beside them, one emitted module per source
+module, nothing bundled. It reuses the root's own emit steps rather than
+running a second build system.
+
+The library must be built first (`npm run build` at the repository root),
+because this package imports it by package specifier and resolves it through
+its `dist`. CI runs both in that order.
+
+`check:dist` runs the same two gates as the root package: no dynamic code in
+anything shipped, and no private artefact or unresolvable **relative**
+specifier in `dist`. It does not resolve bare ones, so the import of
+`@maroonedog/luq/schema-tooling` that every emitted module carries is not its
+business — that is covered by loading the built entries for real, which
+`test/built-package.test.ts` does under both `require` and ESM.
+
+The tests cover the generator, the keyword table against the library's, the
+built CommonJS and ESM entries, and one end-to-end case that writes a generated
+module to a temp directory, compiles it with `tsc --strict`, and runs it
+against a good and a bad document.

package/dist/generate/chain-call.types.d.ts

@@ -0,0 +1,40 @@
+/** One call of one method on the chain. */
+export interface ChainCall {
+    /** The method to call, e.g. "min". */
+    readonly method: string;
+    /** The argument source, emitted verbatim, e.g. ["3"]. Empty gives `.min()`. */
+    readonly args: readonly string[];
+    /**
+     * The export name of the plugin carrying this method, e.g.
+     * "stringMinPlugin". The import statements are built by collecting these.
+     */
+    readonly pluginExport: string;
+    /** The subpath to import it from, e.g. "@maroonedog/luq/plugins/stringMin". */
+    readonly pluginSubpath: string;
+}
+/** One field's declaration, becoming `.v(path, b => b.<slot>....)`. */
+export interface FieldChain {
+    /** The first argument of `.v()`, e.g. "items[*].sku". */
+    readonly path: string;
+    /** The slot name following `b.`, e.g. "string". */
+    readonly slot: string;
+    readonly calls: readonly ChainCall[];
+    /**
+     * The keywords not emitted, with reasons. Carried through so that dropping
+     * one is never silent, and printed in a comment in the output.
+     */
+    readonly skipped: readonly SkippedKeyword[];
+}
+export interface SkippedKeyword {
+    readonly keyword: string;
+    readonly reason: string;
+}
+export interface GeneratedModule {
+    readonly source: string;
+    /** The export names of the plugins used, deduplicated and sorted. */
+    readonly pluginExports: readonly string[];
+    /** Everything skipped, across all fields, for the caller to report. */
+    readonly skipped: readonly (SkippedKeyword & {
+        readonly path: string;
+    })[];
+}

package/dist/generate/chain-call.types.js

@@ -0,0 +1,10 @@
+"use strict";
+// ===========================================================================
+// luq-codegen/src/generate/chain-call.types.ts
+//
+// The intermediate form of one generated chain. Going through it instead of
+// concatenating strings is what makes the set of plugins to import countable
+// afterwards. Built by concatenation, a missing import first shows up in the
+// user's compiler rather than here.
+// ===========================================================================
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/generate/chain-call.types.mjs

@@ -0,0 +1,9 @@
+// ===========================================================================
+// luq-codegen/src/generate/chain-call.types.ts
+//
+// The intermediate form of one generated chain. Going through it instead of
+// concatenating strings is what makes the set of plugins to import countable
+// afterwards. Built by concatenation, a missing import first shows up in the
+// user's compiler rather than here.
+// ===========================================================================
+export {};

package/dist/generate/generate-validator-module.d.ts

@@ -0,0 +1,11 @@
+import type { Draft07Schema } from "@maroonedog/luq/schema-tooling";
+import type { GeneratedModule } from "./chain-call.types";
+export interface GenerateOptions {
+    /** The name of the const to generate, e.g. "validateOrder". */
+    readonly validatorName: string;
+    /** The type name to put in `.for<T>()`, e.g. 'components["schemas"]["Order"]'. */
+    readonly typeExpression: string;
+    /** The line importing that type. Omitted, the type is assumed in scope. */
+    readonly typeImport?: string;
+}
+export declare function generateValidatorModule(schema: Draft07Schema, options: GenerateOptions): GeneratedModule;

package/dist/generate/generate-validator-module.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateValidatorModule = generateValidatorModule;
+// ===========================================================================
+// luq-codegen/src/generate/generate-validator-module.ts
+//
+// One schema to the source of a module exporting one validator.
+//
+// Flattening reuses the library's own. The generated code and the run-time
+// conversion decide paths with the same function, which makes it structurally
+// impossible for the two to disagree about what a path looks like.
+// ===========================================================================
+const schema_tooling_1 = require("@maroonedog/luq/schema-tooling");
+const keyword_to_chain_call_1 = require("./keyword-to-chain-call");
+const resolve_required_path_1 = require("./resolve-required-path");
+const slot_for_schema_1 = require("./slot-for-schema");
+const PRESENCE_REQUIRED = {
+    method: "required",
+    args: [],
+    pluginExport: "requiredPlugin",
+    pluginSubpath: "@maroonedog/luq/plugins/required",
+};
+const PRESENCE_OPTIONAL = {
+    method: "optional",
+    args: [],
+    pluginExport: "optionalPlugin",
+    pluginSubpath: "@maroonedog/luq/plugins/optional",
+};
+function toFieldChain(path, schema, isRequired) {
+    const calls = [isRequired ? PRESENCE_REQUIRED : PRESENCE_OPTIONAL];
+    const skipped = [];
+    // Walked in key order rather than order of appearance. Letting how the
+    // schema was written decide the chain order fills every diff with noise.
+    for (const keyword of Object.keys(schema).sort()) {
+        const outcome = (0, keyword_to_chain_call_1.keywordToChainCall)(keyword, schema[keyword]);
+        if (outcome.call !== undefined)
+            calls.push(outcome.call);
+        if (outcome.skipped !== undefined)
+            skipped.push(outcome.skipped);
+    }
+    return { path, slot: (0, slot_for_schema_1.slotForSchema)(schema), calls, skipped };
+}
+function renderChain(field) {
+    const body = field.calls
+        .map((call) => `.${call.method}(${call.args.join(", ")})`)
+        .join("");
+    return `  .v(${JSON.stringify(field.path)}, (b) => b.${field.slot}${body})`;
+}
+function renderImports(pluginExports, typeImport) {
+    const lines = ['import { Builder } from "@maroonedog/luq";'];
+    if (typeImport !== undefined)
+        lines.push(typeImport);
+    for (const entry of pluginExports) {
+        lines.push(`import { ${entry.name} } from ${JSON.stringify(entry.subpath)};`);
+    }
+    return lines.join("\n");
+}
+/**
+ * Skipped keywords are listed in a comment at the top of the output, so a
+ * reader can see what the generator dropped without leaving the file.
+ */
+function renderSkippedNotice(skipped) {
+    if (skipped.length === 0)
+        return "";
+    const lines = skipped.map((entry) => `//   ${entry.path || "(root)"}: ${entry.keyword} — ${entry.reason}`);
+    return [
+        "//",
+        "// Keywords in this schema that did not become rules:",
+        ...lines,
+        "",
+    ].join("\n");
+}
+function generateValidatorModule(schema, options) {
+    const declarations = (0, schema_tooling_1.flattenSchema)(schema, schema_tooling_1.readChildSchemas);
+    const fields = declarations.map((declaration) => {
+        // Flattening reports isRequired for the root's own keys only. A nested
+        // required is a rule on the object at run time, and the chain has nowhere
+        // to put that. See resolve-required-path.ts for when it can be lowered.
+        const safelyRequired = declaration.isRequired || (0, resolve_required_path_1.isSafelyRequired)(schema, declaration.path);
+        const field = toFieldChain(declaration.path, declaration.schema, safelyRequired);
+        if (safelyRequired || !(0, resolve_required_path_1.isListedByParent)(schema, declaration.path)) {
+            return field;
+        }
+        return {
+            ...field,
+            skipped: [
+                ...field.skipped,
+                {
+                    keyword: "required",
+                    reason: "the parent schema marks it required, but an ancestor object is " +
+                        "not, so .required() would wrongly reject a document missing that " +
+                        "ancestor; Draft-07 applies a subschema only to a value that " +
+                        "exists, so this was emitted as optional",
+                },
+            ],
+        };
+    });
+    const byExport = new Map();
+    for (const field of fields) {
+        for (const call of field.calls)
+            byExport.set(call.pluginExport, call.pluginSubpath);
+    }
+    const pluginExports = [...byExport.entries()]
+        .map(([name, subpath]) => ({ name, subpath }))
+        .sort((left, right) => left.name.localeCompare(right.name));
+    const skipped = fields.flatMap((field) => field.skipped.map((entry) => ({ ...entry, path: field.path })));
+    const uses = pluginExports.map((entry) => `  .use(${entry.name})`).join("\n");
+    const chains = fields.map(renderChain).join("\n");
+    const source = [
+        "// Generated by @maroonedog/luq-codegen. Do not edit.",
+        "// Rules are declared against the generated type, so a spec change that",
+        "// renames a field makes this file stop compiling instead of drifting.",
+        renderSkippedNotice(skipped),
+        renderImports(pluginExports, options.typeImport),
+        "",
+        `export const ${options.validatorName} = Builder()`,
+        uses,
+        `  .for<${options.typeExpression}>()`,
+        chains,
+        "  .build();",
+        "",
+    ]
+        .filter((part) => part !== "")
+        .join("\n");
+    return {
+        source,
+        pluginExports: pluginExports.map((entry) => entry.name),
+        skipped,
+    };
+}

package/dist/generate/generate-validator-module.mjs

@@ -0,0 +1,127 @@
+// ===========================================================================
+// luq-codegen/src/generate/generate-validator-module.ts
+//
+// One schema to the source of a module exporting one validator.
+//
+// Flattening reuses the library's own. The generated code and the run-time
+// conversion decide paths with the same function, which makes it structurally
+// impossible for the two to disagree about what a path looks like.
+// ===========================================================================
+import { flattenSchema, readChildSchemas } from "@maroonedog/luq/schema-tooling";
+import { keywordToChainCall } from "./keyword-to-chain-call.mjs";
+import { isListedByParent, isSafelyRequired } from "./resolve-required-path.mjs";
+import { slotForSchema } from "./slot-for-schema.mjs";
+const PRESENCE_REQUIRED = {
+    method: "required",
+    args: [],
+    pluginExport: "requiredPlugin",
+    pluginSubpath: "@maroonedog/luq/plugins/required",
+};
+const PRESENCE_OPTIONAL = {
+    method: "optional",
+    args: [],
+    pluginExport: "optionalPlugin",
+    pluginSubpath: "@maroonedog/luq/plugins/optional",
+};
+function toFieldChain(path, schema, isRequired) {
+    const calls = [isRequired ? PRESENCE_REQUIRED : PRESENCE_OPTIONAL];
+    const skipped = [];
+    // Walked in key order rather than order of appearance. Letting how the
+    // schema was written decide the chain order fills every diff with noise.
+    for (const keyword of Object.keys(schema).sort()) {
+        const outcome = keywordToChainCall(keyword, schema[keyword]);
+        if (outcome.call !== undefined)
+            calls.push(outcome.call);
+        if (outcome.skipped !== undefined)
+            skipped.push(outcome.skipped);
+    }
+    return { path, slot: slotForSchema(schema), calls, skipped };
+}
+function renderChain(field) {
+    const body = field.calls
+        .map((call) => `.${call.method}(${call.args.join(", ")})`)
+        .join("");
+    return `  .v(${JSON.stringify(field.path)}, (b) => b.${field.slot}${body})`;
+}
+function renderImports(pluginExports, typeImport) {
+    const lines = ['import { Builder } from "@maroonedog/luq";'];
+    if (typeImport !== undefined)
+        lines.push(typeImport);
+    for (const entry of pluginExports) {
+        lines.push(`import { ${entry.name} } from ${JSON.stringify(entry.subpath)};`);
+    }
+    return lines.join("\n");
+}
+/**
+ * Skipped keywords are listed in a comment at the top of the output, so a
+ * reader can see what the generator dropped without leaving the file.
+ */
+function renderSkippedNotice(skipped) {
+    if (skipped.length === 0)
+        return "";
+    const lines = skipped.map((entry) => `//   ${entry.path || "(root)"}: ${entry.keyword} — ${entry.reason}`);
+    return [
+        "//",
+        "// Keywords in this schema that did not become rules:",
+        ...lines,
+        "",
+    ].join("\n");
+}
+export function generateValidatorModule(schema, options) {
+    const declarations = flattenSchema(schema, readChildSchemas);
+    const fields = declarations.map((declaration) => {
+        // Flattening reports isRequired for the root's own keys only. A nested
+        // required is a rule on the object at run time, and the chain has nowhere
+        // to put that. See resolve-required-path.ts for when it can be lowered.
+        const safelyRequired = declaration.isRequired || isSafelyRequired(schema, declaration.path);
+        const field = toFieldChain(declaration.path, declaration.schema, safelyRequired);
+        if (safelyRequired || !isListedByParent(schema, declaration.path)) {
+            return field;
+        }
+        return {
+            ...field,
+            skipped: [
+                ...field.skipped,
+                {
+                    keyword: "required",
+                    reason: "the parent schema marks it required, but an ancestor object is " +
+                        "not, so .required() would wrongly reject a document missing that " +
+                        "ancestor; Draft-07 applies a subschema only to a value that " +
+                        "exists, so this was emitted as optional",
+                },
+            ],
+        };
+    });
+    const byExport = new Map();
+    for (const field of fields) {
+        for (const call of field.calls)
+            byExport.set(call.pluginExport, call.pluginSubpath);
+    }
+    const pluginExports = [...byExport.entries()]
+        .map(([name, subpath]) => ({ name, subpath }))
+        .sort((left, right) => left.name.localeCompare(right.name));
+    const skipped = fields.flatMap((field) => field.skipped.map((entry) => ({ ...entry, path: field.path })));
+    const uses = pluginExports.map((entry) => `  .use(${entry.name})`).join("\n");
+    const chains = fields.map(renderChain).join("\n");
+    const source = [
+        "// Generated by @maroonedog/luq-codegen. Do not edit.",
+        "// Rules are declared against the generated type, so a spec change that",
+        "// renames a field makes this file stop compiling instead of drifting.",
+        renderSkippedNotice(skipped),
+        renderImports(pluginExports, options.typeImport),
+        "",
+        `export const ${options.validatorName} = Builder()`,
+        uses,
+        `  .for<${options.typeExpression}>()`,
+        chains,
+        "  .build();",
+        "",
+    ]
+        .filter((part) => part !== "")
+        .join("\n");
+    return {
+        source,
+        pluginExports: pluginExports.map((entry) => entry.name),
+        skipped,
+    };
+}

package/dist/generate/keyword-to-chain-call.d.ts

@@ -0,0 +1,10 @@
+import type { ChainCall, SkippedKeyword } from "./chain-call.types";
+export interface KeywordOutcome {
+    readonly call?: ChainCall;
+    readonly skipped?: SkippedKeyword;
+}
+export declare function keywordToChainCall(keyword: string, value: unknown): KeywordOutcome;
+/** Exported so a test can inspect the table itself. */
+export declare const BOUND_KEYWORDS: readonly string[];
+export declare const BOUND_FORMATS: readonly string[];
+export declare const STRUCTURAL_KEYWORDS: readonly string[];

package/dist/generate/keyword-to-chain-call.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.STRUCTURAL_KEYWORDS = exports.BOUND_FORMATS = exports.BOUND_KEYWORDS = void 0;
+exports.keywordToChainCall = keywordToChainCall;
+/** Keyword to the method it becomes, and the plugin carrying that method. */
+const BINDINGS = {
+    minLength: { method: "min", pluginExport: "stringMinPlugin", subpathName: "stringMin" },
+    maxLength: { method: "max", pluginExport: "stringMaxPlugin", subpathName: "stringMax" },
+    pattern: { method: "pattern", pluginExport: "stringPatternPlugin", subpathName: "stringPattern" },
+    minimum: { method: "min", pluginExport: "numberMinPlugin", subpathName: "numberMin" },
+    maximum: { method: "max", pluginExport: "numberMaxPlugin", subpathName: "numberMax" },
+    multipleOf: { method: "multipleOf", pluginExport: "numberMultipleOfPlugin", subpathName: "numberMultipleOf" },
+    minItems: { method: "minLength", pluginExport: "arrayMinLengthPlugin", subpathName: "arrayMinLength" },
+    maxItems: { method: "maxLength", pluginExport: "arrayMaxLengthPlugin", subpathName: "arrayMaxLength" },
+    uniqueItems: { method: "unique", pluginExport: "arrayUniquePlugin", subpathName: "arrayUnique" },
+    minProperties: { method: "minProperties", pluginExport: "objectMinPropertiesPlugin", subpathName: "objectMinProperties" },
+    maxProperties: { method: "maxProperties", pluginExport: "objectMaxPropertiesPlugin", subpathName: "objectMaxProperties" },
+    const: { method: "literal", pluginExport: "literalPlugin", subpathName: "literal" },
+    enum: { method: "oneOf", pluginExport: "oneOfPlugin", subpathName: "oneOf" },
+};
+/** A format value to its method and plugin, paired with the library's format map. */
+const FORMAT_BINDINGS = {
+    email: { method: "email", pluginExport: "stringEmailPlugin", subpathName: "stringEmail" },
+    uuid: { method: "uuid", pluginExport: "uuidPlugin", subpathName: "uuid" },
+    uri: { method: "url", pluginExport: "stringUrlPlugin", subpathName: "stringUrl" },
+    hostname: { method: "hostname", pluginExport: "stringHostnamePlugin", subpathName: "stringHostname" },
+    ipv4: { method: "ipv4", pluginExport: "stringIpv4Plugin", subpathName: "stringIpv4" },
+    ipv6: { method: "ipv6", pluginExport: "stringIpv6Plugin", subpathName: "stringIpv6" },
+    date: { method: "date", pluginExport: "stringDatePlugin", subpathName: "stringDate" },
+    "date-time": { method: "datetime", pluginExport: "stringDatetimePlugin", subpathName: "stringDatetime" },
+    time: { method: "time", pluginExport: "stringTimePlugin", subpathName: "stringTime" },
+    duration: { method: "duration", pluginExport: "stringDurationPlugin", subpathName: "stringDuration" },
+    "json-pointer": { method: "jsonPointer", pluginExport: "stringJsonPointerPlugin", subpathName: "stringJsonPointer" },
+    iri: { method: "iri", pluginExport: "stringIriPlugin", subpathName: "stringIri" },
+};
+/** Handled structurally, so never turned into a chain call here. */
+const STRUCTURAL = {
+    type: "selects the slot; it is not a method",
+    properties: "expands into declarations for the child fields",
+    items: "expands into the declaration for array elements",
+    required: "held by the parent, as presence",
+    allOf: "folded away during flattening",
+    $ref: "resolved before flattening",
+    title: "annotation; not validated",
+    description: "annotation; not validated",
+    default: "annotation; not validated",
+    example: "annotation; not validated",
+    examples: "annotation; not validated",
+    deprecated: "annotation; not validated",
+    readOnly: "an OpenAPI direction marker; not lowered into validation",
+    writeOnly: "an OpenAPI direction marker; not lowered into validation",
+    nullable: "handled as presence",
+};
+function subpathOf(name) {
+    return `@maroonedog/luq/plugins/${name}`;
+}
+/**
+ * Values are embedded as source, so they go through JSON.stringify. Never as
+ * a regular-expression literal: a pattern is passed as a string, and making it
+ * a literal would have the escapes interpreted twice.
+ */
+function renderValue(value) {
+    return JSON.stringify(value);
+}
+function keywordToChainCall(keyword, value) {
+    const structural = STRUCTURAL[keyword];
+    if (structural !== undefined) {
+        return { skipped: { keyword, reason: structural } };
+    }
+    if (keyword === "format") {
+        if (typeof value !== "string") {
+            return { skipped: { keyword, reason: "the format value is not a string" } };
+        }
+        const binding = FORMAT_BINDINGS[value];
+        if (binding === undefined) {
+            return {
+                skipped: { keyword, reason: `no plugin corresponds to format "${value}"` },
+            };
+        }
+        return {
+            call: {
+                method: binding.method,
+                args: [],
+                pluginExport: binding.pluginExport,
+                pluginSubpath: subpathOf(binding.subpathName),
+            },
+        };
+    }
+    // In Draft-07 uniqueItems: false disables the constraint, so emit no rule.
+    if (keyword === "uniqueItems" && value !== true) {
+        return { skipped: { keyword, reason: "uniqueItems: false is not a constraint" } };
+    }
+    const binding = BINDINGS[keyword];
+    if (binding === undefined) {
+        return {
+            skipped: { keyword, reason: "no chain method corresponds to it" },
+        };
+    }
+    return {
+        call: {
+            method: binding.method,
+            args: keyword === "uniqueItems" ? [] : [renderValue(value)],
+            pluginExport: binding.pluginExport,
+            pluginSubpath: subpathOf(binding.subpathName),
+        },
+    };
+}
+/** Exported so a test can inspect the table itself. */
+exports.BOUND_KEYWORDS = Object.keys(BINDINGS);
+exports.BOUND_FORMATS = Object.keys(FORMAT_BINDINGS);
+exports.STRUCTURAL_KEYWORDS = Object.keys(STRUCTURAL);

package/dist/generate/keyword-to-chain-call.mjs

@@ -0,0 +1,107 @@
+/** Keyword to the method it becomes, and the plugin carrying that method. */
+const BINDINGS = {
+    minLength: { method: "min", pluginExport: "stringMinPlugin", subpathName: "stringMin" },
+    maxLength: { method: "max", pluginExport: "stringMaxPlugin", subpathName: "stringMax" },
+    pattern: { method: "pattern", pluginExport: "stringPatternPlugin", subpathName: "stringPattern" },
+    minimum: { method: "min", pluginExport: "numberMinPlugin", subpathName: "numberMin" },
+    maximum: { method: "max", pluginExport: "numberMaxPlugin", subpathName: "numberMax" },
+    multipleOf: { method: "multipleOf", pluginExport: "numberMultipleOfPlugin", subpathName: "numberMultipleOf" },
+    minItems: { method: "minLength", pluginExport: "arrayMinLengthPlugin", subpathName: "arrayMinLength" },
+    maxItems: { method: "maxLength", pluginExport: "arrayMaxLengthPlugin", subpathName: "arrayMaxLength" },
+    uniqueItems: { method: "unique", pluginExport: "arrayUniquePlugin", subpathName: "arrayUnique" },
+    minProperties: { method: "minProperties", pluginExport: "objectMinPropertiesPlugin", subpathName: "objectMinProperties" },
+    maxProperties: { method: "maxProperties", pluginExport: "objectMaxPropertiesPlugin", subpathName: "objectMaxProperties" },
+    const: { method: "literal", pluginExport: "literalPlugin", subpathName: "literal" },
+    enum: { method: "oneOf", pluginExport: "oneOfPlugin", subpathName: "oneOf" },
+};
+/** A format value to its method and plugin, paired with the library's format map. */
+const FORMAT_BINDINGS = {
+    email: { method: "email", pluginExport: "stringEmailPlugin", subpathName: "stringEmail" },
+    uuid: { method: "uuid", pluginExport: "uuidPlugin", subpathName: "uuid" },
+    uri: { method: "url", pluginExport: "stringUrlPlugin", subpathName: "stringUrl" },
+    hostname: { method: "hostname", pluginExport: "stringHostnamePlugin", subpathName: "stringHostname" },
+    ipv4: { method: "ipv4", pluginExport: "stringIpv4Plugin", subpathName: "stringIpv4" },
+    ipv6: { method: "ipv6", pluginExport: "stringIpv6Plugin", subpathName: "stringIpv6" },
+    date: { method: "date", pluginExport: "stringDatePlugin", subpathName: "stringDate" },
+    "date-time": { method: "datetime", pluginExport: "stringDatetimePlugin", subpathName: "stringDatetime" },
+    time: { method: "time", pluginExport: "stringTimePlugin", subpathName: "stringTime" },
+    duration: { method: "duration", pluginExport: "stringDurationPlugin", subpathName: "stringDuration" },
+    "json-pointer": { method: "jsonPointer", pluginExport: "stringJsonPointerPlugin", subpathName: "stringJsonPointer" },
+    iri: { method: "iri", pluginExport: "stringIriPlugin", subpathName: "stringIri" },
+};
+/** Handled structurally, so never turned into a chain call here. */
+const STRUCTURAL = {
+    type: "selects the slot; it is not a method",
+    properties: "expands into declarations for the child fields",
+    items: "expands into the declaration for array elements",
+    required: "held by the parent, as presence",
+    allOf: "folded away during flattening",
+    $ref: "resolved before flattening",
+    title: "annotation; not validated",
+    description: "annotation; not validated",
+    default: "annotation; not validated",
+    example: "annotation; not validated",
+    examples: "annotation; not validated",
+    deprecated: "annotation; not validated",
+    readOnly: "an OpenAPI direction marker; not lowered into validation",
+    writeOnly: "an OpenAPI direction marker; not lowered into validation",
+    nullable: "handled as presence",
+};
+function subpathOf(name) {
+    return `@maroonedog/luq/plugins/${name}`;
+}
+/**
+ * Values are embedded as source, so they go through JSON.stringify. Never as
+ * a regular-expression literal: a pattern is passed as a string, and making it
+ * a literal would have the escapes interpreted twice.
+ */
+function renderValue(value) {
+    return JSON.stringify(value);
+}
+export function keywordToChainCall(keyword, value) {
+    const structural = STRUCTURAL[keyword];
+    if (structural !== undefined) {
+        return { skipped: { keyword, reason: structural } };
+    }
+    if (keyword === "format") {
+        if (typeof value !== "string") {
+            return { skipped: { keyword, reason: "the format value is not a string" } };
+        }
+        const binding = FORMAT_BINDINGS[value];
+        if (binding === undefined) {
+            return {
+                skipped: { keyword, reason: `no plugin corresponds to format "${value}"` },
+            };
+        }
+        return {
+            call: {
+                method: binding.method,
+                args: [],
+                pluginExport: binding.pluginExport,
+                pluginSubpath: subpathOf(binding.subpathName),
+            },
+        };
+    }
+    // In Draft-07 uniqueItems: false disables the constraint, so emit no rule.
+    if (keyword === "uniqueItems" && value !== true) {
+        return { skipped: { keyword, reason: "uniqueItems: false is not a constraint" } };
+    }
+    const binding = BINDINGS[keyword];
+    if (binding === undefined) {
+        return {
+            skipped: { keyword, reason: "no chain method corresponds to it" },
+        };
+    }
+    return {
+        call: {
+            method: binding.method,
+            args: keyword === "uniqueItems" ? [] : [renderValue(value)],
+            pluginExport: binding.pluginExport,
+            pluginSubpath: subpathOf(binding.subpathName),
+        },
+    };
+}
+/** Exported so a test can inspect the table itself. */
+export const BOUND_KEYWORDS = Object.keys(BINDINGS);
+export const BOUND_FORMATS = Object.keys(FORMAT_BINDINGS);
+export const STRUCTURAL_KEYWORDS = Object.keys(STRUCTURAL);

package/dist/generate/resolve-required-path.d.ts

@@ -0,0 +1,18 @@
+import type { Draft07Schema } from "@maroonedog/luq/schema-tooling";
+/** "items[*].sku" -> ["items[*]", "sku"]; "[*]" stays attached to its key. */
+export declare function splitDeclaredPath(path: string): readonly string[];
+/**
+ * Whether `.required()` may be emitted for that path.
+ *
+ * False as soon as one ancestor object along the way is not itself required.
+ * On false the caller emits `.optional()` instead and reports the omission.
+ */
+export declare function isSafelyRequired(root: Draft07Schema, path: string): boolean;
+/**
+ * Whether the immediate parent schema lists that key in its required set.
+ *
+ * When the path is not safely required, this separates "it was never written
+ * as required" from "it was, but an ancestor makes it unlowerable". Only the
+ * second is reported as skipped.
+ */
+export declare function isListedByParent(root: Draft07Schema, path: string): boolean;

package/dist/generate/resolve-required-path.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.splitDeclaredPath = splitDeclaredPath;
+exports.isSafelyRequired = isSafelyRequired;
+exports.isListedByParent = isListedByParent;
+const schema_tooling_1 = require("@maroonedog/luq/schema-tooling");
+/** "items[*].sku" -> ["items[*]", "sku"]; "[*]" stays attached to its key. */
+function splitDeclaredPath(path) {
+    return path === "" ? [] : path.split(".");
+}
+function propertyOf(schema, key) {
+    const properties = schema.properties;
+    if (properties === null || typeof properties !== "object")
+        return undefined;
+    const child = properties[key];
+    if (!(0, schema_tooling_1.isDraft07Schema)(child))
+        return undefined;
+    return (0, schema_tooling_1.isSchemaObject)(child) ? child : undefined;
+}
+function itemsOf(schema) {
+    const items = schema.items;
+    if (!(0, schema_tooling_1.isDraft07Schema)(items))
+        return undefined;
+    return (0, schema_tooling_1.isSchemaObject)(items) ? items : undefined;
+}
+function listsAsRequired(schema, key) {
+    const required = schema.required;
+    return Array.isArray(required) && required.includes(key);
+}
+/**
+ * Whether `.required()` may be emitted for that path.
+ *
+ * False as soon as one ancestor object along the way is not itself required.
+ * On false the caller emits `.optional()` instead and reports the omission.
+ */
+function isSafelyRequired(root, path) {
+    if (!(0, schema_tooling_1.isSchemaObject)(root))
+        return false;
+    const steps = splitDeclaredPath(path);
+    if (steps.length === 0)
+        return false;
+    let current = root;
+    for (let index = 0; index < steps.length; index += 1) {
+        const step = steps[index] ?? "";
+        const wildcards = (step.match(/\[\*\]/g) ?? []).length;
+        const key = step.slice(0, step.length - wildcards * 3);
+        if (!listsAsRequired(current, key))
+            return false;
+        const child = propertyOf(current, key);
+        if (child === undefined)
+            return index === steps.length - 1;
+        let descended = child;
+        for (let level = 0; level < wildcards; level += 1) {
+            const element = itemsOf(descended);
+            // With no element schema there is nowhere further to walk. Every
+            // ancestor so far was required, so the last segment may be required.
+            if (element === undefined)
+                return index === steps.length - 1;
+            descended = element;
+        }
+        current = descended;
+    }
+    return true;
+}
+/**
+ * Whether the immediate parent schema lists that key in its required set.
+ *
+ * When the path is not safely required, this separates "it was never written
+ * as required" from "it was, but an ancestor makes it unlowerable". Only the
+ * second is reported as skipped.
+ */
+function isListedByParent(root, path) {
+    if (!(0, schema_tooling_1.isSchemaObject)(root))
+        return false;
+    const steps = splitDeclaredPath(path);
+    if (steps.length === 0)
+        return false;
+    let current = root;
+    for (let index = 0; index < steps.length - 1; index += 1) {
+        const step = steps[index] ?? "";
+        const wildcards = (step.match(/\[\*\]/g) ?? []).length;
+        const key = step.slice(0, step.length - wildcards * 3);
+        const child = propertyOf(current, key);
+        if (child === undefined)
+            return false;
+        let descended = child;
+        for (let level = 0; level < wildcards; level += 1) {
+            const element = itemsOf(descended);
+            if (element === undefined)
+                return false;
+            descended = element;
+        }
+        current = descended;
+    }
+    const last = steps[steps.length - 1] ?? "";
+    const wildcards = (last.match(/\[\*\]/g) ?? []).length;
+    return listsAsRequired(current, last.slice(0, last.length - wildcards * 3));
+}

package/dist/generate/resolve-required-path.mjs

@@ -0,0 +1,93 @@
+import { isDraft07Schema, isSchemaObject, } from "@maroonedog/luq/schema-tooling";
+/** "items[*].sku" -> ["items[*]", "sku"]; "[*]" stays attached to its key. */
+export function splitDeclaredPath(path) {
+    return path === "" ? [] : path.split(".");
+}
+function propertyOf(schema, key) {
+    const properties = schema.properties;
+    if (properties === null || typeof properties !== "object")
+        return undefined;
+    const child = properties[key];
+    if (!isDraft07Schema(child))
+        return undefined;
+    return isSchemaObject(child) ? child : undefined;
+}
+function itemsOf(schema) {
+    const items = schema.items;
+    if (!isDraft07Schema(items))
+        return undefined;
+    return isSchemaObject(items) ? items : undefined;
+}
+function listsAsRequired(schema, key) {
+    const required = schema.required;
+    return Array.isArray(required) && required.includes(key);
+}
+/**
+ * Whether `.required()` may be emitted for that path.
+ *
+ * False as soon as one ancestor object along the way is not itself required.
+ * On false the caller emits `.optional()` instead and reports the omission.
+ */
+export function isSafelyRequired(root, path) {
+    if (!isSchemaObject(root))
+        return false;
+    const steps = splitDeclaredPath(path);
+    if (steps.length === 0)
+        return false;
+    let current = root;
+    for (let index = 0; index < steps.length; index += 1) {
+        const step = steps[index] ?? "";
+        const wildcards = (step.match(/\[\*\]/g) ?? []).length;
+        const key = step.slice(0, step.length - wildcards * 3);
+        if (!listsAsRequired(current, key))
+            return false;
+        const child = propertyOf(current, key);
+        if (child === undefined)
+            return index === steps.length - 1;
+        let descended = child;
+        for (let level = 0; level < wildcards; level += 1) {
+            const element = itemsOf(descended);
+            // With no element schema there is nowhere further to walk. Every
+            // ancestor so far was required, so the last segment may be required.
+            if (element === undefined)
+                return index === steps.length - 1;
+            descended = element;
+        }
+        current = descended;
+    }
+    return true;
+}
+/**
+ * Whether the immediate parent schema lists that key in its required set.
+ *
+ * When the path is not safely required, this separates "it was never written
+ * as required" from "it was, but an ancestor makes it unlowerable". Only the
+ * second is reported as skipped.
+ */
+export function isListedByParent(root, path) {
+    if (!isSchemaObject(root))
+        return false;
+    const steps = splitDeclaredPath(path);
+    if (steps.length === 0)
+        return false;
+    let current = root;
+    for (let index = 0; index < steps.length - 1; index += 1) {
+        const step = steps[index] ?? "";
+        const wildcards = (step.match(/\[\*\]/g) ?? []).length;
+        const key = step.slice(0, step.length - wildcards * 3);
+        const child = propertyOf(current, key);
+        if (child === undefined)
+            return false;
+        let descended = child;
+        for (let level = 0; level < wildcards; level += 1) {
+            const element = itemsOf(descended);
+            if (element === undefined)
+                return false;
+            descended = element;
+        }
+        current = descended;
+    }
+    const last = steps[steps.length - 1] ?? "";
+    const wildcards = (last.match(/\[\*\]/g) ?? []).length;
+    return listsAsRequired(current, last.slice(0, last.length - wildcards * 3));
+}

package/dist/generate/slot-for-schema.d.ts

@@ -0,0 +1,13 @@
+import type { Draft07SchemaObject } from "@maroonedog/luq/schema-tooling";
+/**
+ * A schema with no type, with several types, or with null alone belongs to no
+ * slot, so it falls to "any".
+ *
+ * That narrows what can be written on it. A plugin serves the slots it
+ * declares, and the ones declaring "any" are the type-agnostic rules —
+ * presence and the value comparisons. A rule that belongs to one type does
+ * not appear: `oneOf` serves string, number and boolean, so a schema whose
+ * type could not be decided gets no `oneOf` call and the keyword is reported
+ * skipped rather than emitted onto a slot that would not compile.
+ */
+export declare function slotForSchema(schema: Draft07SchemaObject): string;

package/dist/generate/slot-for-schema.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.slotForSchema = slotForSchema;
+const SLOT_BY_TYPE = {
+    string: "string",
+    number: "number",
+    integer: "number",
+    boolean: "boolean",
+    array: "array",
+    object: "object",
+};
+/**
+ * A schema with no type, with several types, or with null alone belongs to no
+ * slot, so it falls to "any".
+ *
+ * That narrows what can be written on it. A plugin serves the slots it
+ * declares, and the ones declaring "any" are the type-agnostic rules —
+ * presence and the value comparisons. A rule that belongs to one type does
+ * not appear: `oneOf` serves string, number and boolean, so a schema whose
+ * type could not be decided gets no `oneOf` call and the keyword is reported
+ * skipped rather than emitted onto a slot that would not compile.
+ */
+function slotForSchema(schema) {
+    const type = schema.type;
+    if (typeof type !== "string")
+        return "any";
+    return SLOT_BY_TYPE[type] ?? "any";
+}

package/dist/generate/slot-for-schema.mjs

@@ -0,0 +1,25 @@
+const SLOT_BY_TYPE = {
+    string: "string",
+    number: "number",
+    integer: "number",
+    boolean: "boolean",
+    array: "array",
+    object: "object",
+};
+/**
+ * A schema with no type, with several types, or with null alone belongs to no
+ * slot, so it falls to "any".
+ *
+ * That narrows what can be written on it. A plugin serves the slots it
+ * declares, and the ones declaring "any" are the type-agnostic rules —
+ * presence and the value comparisons. A rule that belongs to one type does
+ * not appear: `oneOf` serves string, number and boolean, so a schema whose
+ * type could not be decided gets no `oneOf` call and the keyword is reported
+ * skipped rather than emitted onto a slot that would not compile.
+ */
+export function slotForSchema(schema) {
+    const type = schema.type;
+    if (typeof type !== "string")
+        return "any";
+    return SLOT_BY_TYPE[type] ?? "any";
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { generateValidatorModule } from "./generate/generate-validator-module";
+export type { GenerateOptions } from "./generate/generate-validator-module";
+export type { ChainCall, FieldChain, GeneratedModule, SkippedKeyword, } from "./generate/chain-call.types";

package/dist/index.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateValidatorModule = void 0;
+// ===========================================================================
+// luq-codegen/src/index.ts — re-exports only. Nothing is defined here.
+//
+// The one entry point this package publishes. Every module beside it is
+// reachable only through what is named below, so moving or splitting one of
+// them is not a breaking change for anybody.
+// ===========================================================================
+var generate_validator_module_1 = require("./generate/generate-validator-module");
+Object.defineProperty(exports, "generateValidatorModule", { enumerable: true, get: function () { return generate_validator_module_1.generateValidatorModule; } });

package/dist/index.mjs

@@ -0,0 +1,8 @@
+// ===========================================================================
+// luq-codegen/src/index.ts — re-exports only. Nothing is defined here.
+//
+// The one entry point this package publishes. Every module beside it is
+// reachable only through what is named below, so moving or splitting one of
+// them is not a breaking change for anybody.
+// ===========================================================================
+export { generateValidatorModule } from "./generate/generate-validator-module.mjs";

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@maroonedog/luq-codegen",
+  "version": "0.1.0",
+  "description": "Generates the source of a Luq validator module from a JSON Schema Draft-07 object, such as an OpenAPI 3.0 component schema.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/maroonedog/luq.git",
+    "directory": "luq-codegen"
+  },
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": ["dist"],
+  "sideEffects": false,
+  "scripts": {
+    "build": "npx ts-node --project ../scripts/tsconfig.json ../scripts/build-luq-codegen.ts",
+    "typecheck": "tsc --noEmit -p tsconfig.json",
+    "test": "jest --no-watch --no-watchman -c jest.config.cjs",
+    "check:no-dynamic-code": "npx ts-node --project ../scripts/tsconfig.json ../scripts/check-no-dynamic-code.ts luq-codegen",
+    "check:dist-layout": "npx ts-node --project ../scripts/tsconfig.json ../scripts/check-dist-layout.ts luq-codegen",
+    "check:dist": "npm run check:no-dynamic-code && npm run check:dist-layout",
+    "verify": "npm run typecheck && npm run build && npm run check:dist && npm test",
+    "prepack": "npm run build",
+    "prepublishOnly": "npm run verify"
+  },
+  "peerDependencies": {
+    "@maroonedog/luq": ">=2.4.0"
+  },
+  "devDependencies": {
+    "@maroonedog/luq": "file:.."
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}