@maroonedog/luq 2.2.0 → 2.3.1

package/dist/standard-schema/standard-schema.types.mjs

@@ -1,12 +1,12 @@
 // ===========================================================================
 // L10 src/standard-schema/standard-schema.types.ts
 //
-// Standard Schema v1 の型を自前で宣言する。@standard-schema/spec に依存しない。
-// 仕様が「型だけのパッケージなので inline してよい」と明示しており、依存を
-// 足せば利用者の node_modules に1つ増える一方で、得るものは何も無いため。
-// 形が仕様からずれていないことは test/type/standard-schema/ が固定する。
+// Declares the Standard Schema v1 types here rather than depending on the
+// spec package. The spec explicitly permits inlining, being types only, and a
+// dependency would add an entry to every user's node_modules for nothing.
+// Type tests pin the shape against the spec so it cannot drift.
 //
-// この層が L10 なのは、Validator (L6) の上に載る変換であり、コアの誰も
-// これを import しないから。import の向きは L6 -> L10 ではなく L10 -> L6。
+// This is the outermost layer because it is a view laid over the validator and
+// nothing in the core imports it. The import direction runs inwards only.
 // ===========================================================================
 export {};

package/dist/standard-schema/to-standard-json-schema.d.ts

@@ -0,0 +1,19 @@
+import type { Validator } from "../builder/validator.types";
+import { type StandardLuqSchema } from "./to-standard-schema";
+/** The spec's Options: target is required, libraryOptions is vendor-defined. */
+export interface JsonSchemaOptions {
+    readonly target: string;
+    readonly libraryOptions?: Record<string, unknown> | undefined;
+}
+interface JsonSchemaConverter {
+    readonly input: (options: JsonSchemaOptions) => Record<string, unknown>;
+    readonly output: (options: JsonSchemaOptions) => Record<string, unknown>;
+}
+/** A `~standard` carrying both validate and jsonSchema. */
+export type StandardJsonSchemaLuqSchema<T extends object, TParsed = T> = StandardLuqSchema<T, TParsed> & {
+    readonly "~standard": StandardLuqSchema<T, TParsed>["~standard"] & {
+        readonly jsonSchema: JsonSchemaConverter;
+    };
+};
+export declare function toStandardJsonSchema<T extends object, TParsed = T>(validator: Validator<T, TParsed>): StandardJsonSchemaLuqSchema<T, TParsed>;
+export {};

package/dist/standard-schema/to-standard-json-schema.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toStandardJsonSchema = toStandardJsonSchema;
+const declared_calls_store_1 = require("../builder/declared-calls-store");
+const assemble_json_schema_1 = require("./assemble-json-schema");
+const json_schema_target_1 = require("./json-schema-target");
+const declarations_unavailable_error_1 = require("./declarations-unavailable-error");
+const unrepresentable_rule_error_1 = require("./unrepresentable-rule-error");
+const to_standard_schema_1 = require("./to-standard-schema");
+const declaration_recorder_1 = require("./declaration-recorder");
+// At module scope, not inside the export: this has to be in place before any
+// build() runs, and a chain that already ran cannot be asked again.
+(0, declaration_recorder_1.installJsonSchemaDeclarationRecorder)();
+function toStandardJsonSchema(validator) {
+    const declared = (0, declared_calls_store_1.readDeclaredCalls)(validator);
+    const emit = (options) => {
+        // Refuse an unsupported target before writing anything. Same order even
+        // when there is nothing to write, or a wrong target passes as an empty
+        // schema instead of an error.
+        const schemaUri = (0, json_schema_target_1.resolveJsonSchemaTarget)(options.target);
+        if (declared === undefined)
+            throw new declarations_unavailable_error_1.DeclarationsUnavailableError();
+        return {
+            $schema: schemaUri,
+            ...(0, assemble_json_schema_1.assembleJsonSchema)(declared, (0, unrepresentable_rule_error_1.readUnrepresentablePolicy)(options.libraryOptions)),
+        };
+    };
+    const standard = (0, to_standard_schema_1.toStandardSchema)(validator);
+    return {
+        ...standard,
+        "~standard": {
+            ...standard["~standard"],
+            jsonSchema: { input: emit, output: emit },
+        },
+    };
+}

package/dist/standard-schema/to-standard-json-schema.mjs

@@ -0,0 +1,33 @@
+import { readDeclaredCalls } from "../builder/declared-calls-store.mjs";
+import { assembleJsonSchema } from "./assemble-json-schema.mjs";
+import { resolveJsonSchemaTarget } from "./json-schema-target.mjs";
+import { DeclarationsUnavailableError } from "./declarations-unavailable-error.mjs";
+import { readUnrepresentablePolicy } from "./unrepresentable-rule-error.mjs";
+import { toStandardSchema } from "./to-standard-schema.mjs";
+import { installJsonSchemaDeclarationRecorder } from "./declaration-recorder.mjs";
+// At module scope, not inside the export: this has to be in place before any
+// build() runs, and a chain that already ran cannot be asked again.
+installJsonSchemaDeclarationRecorder();
+export function toStandardJsonSchema(validator) {
+    const declared = readDeclaredCalls(validator);
+    const emit = (options) => {
+        // Refuse an unsupported target before writing anything. Same order even
+        // when there is nothing to write, or a wrong target passes as an empty
+        // schema instead of an error.
+        const schemaUri = resolveJsonSchemaTarget(options.target);
+        if (declared === undefined)
+            throw new DeclarationsUnavailableError();
+        return {
+            $schema: schemaUri,
+            ...assembleJsonSchema(declared, readUnrepresentablePolicy(options.libraryOptions)),
+        };
+    };
+    const standard = toStandardSchema(validator);
+    return {
+        ...standard,
+        "~standard": {
+            ...standard["~standard"],
+            jsonSchema: { input: emit, output: emit },
+        },
+    };
+}

package/dist/standard-schema/to-standard-schema.d.ts

@@ -1,22 +1,22 @@
 import type { Validator } from "../builder/validator.types";
 import type { StandardSchemaOptions, StandardSchemaResult } from "./standard-schema.types";
 /**
- * 仕様の Props は validate が Promise を返すことも許すが、Luq は必ず同期で返す。
- * ここで同期に絞っておくと、消費側が `await` も型の絞り込みも書かずに済む。
- * 狭めた型は広い型に代入できるので、StandardSchemaV1 としての互換は保たれる
- * (test/type/standard-schema/ の AssignableToSpec がそれを固定している)。
+ * The spec allows validate to return a Promise; this one never does. Pinning
+ * it to synchronous here spares consumers both the `await` and the narrowing.
+ * A narrower type is still assignable to the wider one, so compatibility with
+ * StandardSchemaV1 holds — and a type test pins that.
  */
 interface SynchronousStandardProps<T extends object, TParsed> {
     readonly version: 1;
     readonly vendor: string;
     /**
-     * 第2引数 options は仕様にある。Luq は今のところ読まないが、**受けること
-     * 自体に意味がある**: 引数の少ない関数は多い方に代入できてしまうので、
-     * 書かないと「仕様に合っている」と型が言うのに消費側の options が黙って
-     * 捨てられる。受けた上で無視しているのだと分かる形にしてある。
+     * The second parameter is in the spec and is deliberately declared even
+     * though nothing reads it yet. **Declaring it is the point**: a function
+     * with fewer parameters is assignable to one with more, so leaving it out
+     * would let the type claim conformance while a consumer's options were
+     * silently discarded. Written this way, ignoring them is visible.
      *
-     * libraryOptions に何を入れるかはベンダーごとの取り決めで、Luq はまだ
-     * 何も定義していない。定義したらここで読む。
+     * What goes in libraryOptions is per-vendor, and none is defined yet.
      */
     readonly validate: (value: unknown, options?: StandardSchemaOptions | undefined) => StandardSchemaResult<TParsed>;
     readonly types?: {
@@ -25,17 +25,18 @@ interface SynchronousStandardProps<T extends object, TParsed> {
     } | undefined;
 }
 /**
- * Standard Schema としての Luq バリデータ。
+ * A Luq validator seen as a Standard Schema.
  *
- * Input は `.for<T>()` に渡した型、Output は transform 適用後の型。
- * 推論ではなく宣言から来るので、InferInput が利用者の書いた型そのものを指す。
+ * Input is the type given to `.for<T>()`; Output is that type after
+ * transforms. Both come from the declaration rather than from inference, so
+ * InferInput names the very type the caller wrote.
  */
 export type StandardLuqSchema<T extends object, TParsed = T> = Validator<T, TParsed> & {
     readonly "~standard": SynchronousStandardProps<T, TParsed>;
 };
 /**
- * 元の Validator のメンバー (validate / parse / pick / pickAll) はそのまま残る。
- * 返り値は Validator でもあるので、片方のためにもう片方を諦める必要は無い。
+ * The original validator's members stay. What comes back is still a
+ * Validator, so neither face has to be given up for the other.
  */
 export declare function toStandardSchema<T extends object, TParsed = T>(validator: Validator<T, TParsed>): StandardLuqSchema<T, TParsed>;
 export {};

package/dist/standard-schema/to-standard-schema.js

@@ -2,21 +2,20 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.toStandardSchema = toStandardSchema;
 const split_issue_path_1 = require("./split-issue-path");
-/** package.json の name と揃える。消費側がエラー表示に使う。 */
+/** Matches the package name. Consumers show it in error output. */
 const VENDOR = "luq";
 const COLLECT_EVERY_ISSUE = {
     abortEarly: false,
     abortEarlyOnEachField: false,
 };
 /**
- * 元の Validator のメンバー (validate / parse / pick / pickAll) はそのまま残る。
- * 返り値は Validator でもあるので、片方のためにもう片方を諦める必要は無い。
+ * The original validator's members stay. What comes back is still a
+ * Validator, so neither face has to be given up for the other.
  */
 function toStandardSchema(validator) {
-    // アサーションを書かずに組み立てる。src/core/type-erasure.ts が
-    // 「型を破ってよい唯一の場所」で、ここはその場所ではない。
-    // 各メンバーを明示的に写すので、Validator に新しいメンバーが増えたときは
-    // ここがコンパイルエラーになる — 黙って落ちるより良い。
+    // Assembled without a type assertion; this is not a file allowed to write
+    // one. Copying each member by name means a new member on Validator breaks
+    // the build here, which beats being dropped in silence.
     const props = {
         version: 1,
         vendor: VENDOR,
@@ -36,25 +35,19 @@ function toStandardSchema(validator) {
     };
 }
 /**
- * code と severity は仕様に置き場所が無いので落ちる。message は Luq が
- * 組み立て済みのものをそのまま渡す。
+ * code and severity have nowhere to go in the spec, so they are dropped. The
+ * message is passed through as already composed.
  */
 function toStandardIssue(issue) {
     return { message: issue.message, path: (0, split_issue_path_1.splitIssuePath)(issue.path) };
 }
 // ---------------------------------------------------------------------------
-// なぜコアの build() が ~standard を常に生やさないのか（実測に基づく判断）
+// Why build() does not simply put ~standard on every validator.
 //
-//   core-only                      gzip  7,420 B
-//   core + standard-schema         gzip  7,732 B   (+312 B)
-//   six-plugin                     gzip  8,373 B
-//   six-plugin + standard-schema   gzip  8,692 B   (+319 B)
-//
-// コアに同梱すると、Standard Schema を使わない利用者も 312 B を払う。中核が
-// 7,420 B なので 4.2% にあたり、「使った分しか入らない」という約束と噛み合わない。
-// サブパスにしておけば import しない限り 0 B で、tRPC などに渡したい人だけが払う。
-//
-// 代償は、利用者が toStandardSchema() で1回包む必要があること。build() が
-// 直接 ~standard を持つほうが体験は良いが、その体験のために全員に課金する形に
-// なるので取らなかった。将来コアに入れるなら、この 312 B が判断材料になる。
+// It would be the nicer experience — no wrapping call — but it bills everyone
+// for it, including the majority who never hand a validator to a spec
+// consumer. Measured against the core bundle the surcharge was a few percent,
+// which does not fit "you only ship what you used". As a subpath it costs
+// nothing until imported. Re-measure before revisiting the decision; the
+// figures live with the size budget, not here.
 // ---------------------------------------------------------------------------

package/dist/standard-schema/to-standard-schema.mjs

@@ -1,19 +1,18 @@
 import { splitIssuePath } from "./split-issue-path.mjs";
-/** package.json の name と揃える。消費側がエラー表示に使う。 */
+/** Matches the package name. Consumers show it in error output. */
 const VENDOR = "luq";
 const COLLECT_EVERY_ISSUE = {
     abortEarly: false,
     abortEarlyOnEachField: false,
 };
 /**
- * 元の Validator のメンバー (validate / parse / pick / pickAll) はそのまま残る。
- * 返り値は Validator でもあるので、片方のためにもう片方を諦める必要は無い。
+ * The original validator's members stay. What comes back is still a
+ * Validator, so neither face has to be given up for the other.
  */
 export function toStandardSchema(validator) {
-    // アサーションを書かずに組み立てる。src/core/type-erasure.ts が
-    // 「型を破ってよい唯一の場所」で、ここはその場所ではない。
-    // 各メンバーを明示的に写すので、Validator に新しいメンバーが増えたときは
-    // ここがコンパイルエラーになる — 黙って落ちるより良い。
+    // Assembled without a type assertion; this is not a file allowed to write
+    // one. Copying each member by name means a new member on Validator breaks
+    // the build here, which beats being dropped in silence.
     const props = {
         version: 1,
         vendor: VENDOR,
@@ -33,25 +32,19 @@ export function toStandardSchema(validator) {
     };
 }
 /**
- * code と severity は仕様に置き場所が無いので落ちる。message は Luq が
- * 組み立て済みのものをそのまま渡す。
+ * code and severity have nowhere to go in the spec, so they are dropped. The
+ * message is passed through as already composed.
  */
 function toStandardIssue(issue) {
     return { message: issue.message, path: splitIssuePath(issue.path) };
 }
 // ---------------------------------------------------------------------------
-// なぜコアの build() が ~standard を常に生やさないのか（実測に基づく判断）
+// Why build() does not simply put ~standard on every validator.
 //
-//   core-only                      gzip  7,420 B
-//   core + standard-schema         gzip  7,732 B   (+312 B)
-//   six-plugin                     gzip  8,373 B
-//   six-plugin + standard-schema   gzip  8,692 B   (+319 B)
-//
-// コアに同梱すると、Standard Schema を使わない利用者も 312 B を払う。中核が
-// 7,420 B なので 4.2% にあたり、「使った分しか入らない」という約束と噛み合わない。
-// サブパスにしておけば import しない限り 0 B で、tRPC などに渡したい人だけが払う。
-//
-// 代償は、利用者が toStandardSchema() で1回包む必要があること。build() が
-// 直接 ~standard を持つほうが体験は良いが、その体験のために全員に課金する形に
-// なるので取らなかった。将来コアに入れるなら、この 312 B が判断材料になる。
+// It would be the nicer experience — no wrapping call — but it bills everyone
+// for it, including the majority who never hand a validator to a spec
+// consumer. Measured against the core bundle the surcharge was a few percent,
+// which does not fit "you only ship what you used". As a subpath it costs
+// nothing until imported. Re-measure before revisiting the decision; the
+// figures live with the size budget, not here.
 // ---------------------------------------------------------------------------

package/dist/standard-schema/unrepresentable-rule-error.d.ts

@@ -0,0 +1,15 @@
+export declare class UnrepresentableRuleError extends Error {
+    readonly fieldPath: string;
+    readonly pluginName: string;
+    readonly reason: string;
+    constructor(fieldPath: string, pluginName: string, reason: string);
+}
+/** What to do with an unwritable declaration. Defaults to "throw". */
+export type UnrepresentablePolicy = "throw" | "omit";
+/**
+ * Reads the policy out of `libraryOptions`.
+ *
+ * An unrecognised value falls to throw. A misspelled `omit` landing on the
+ * strict side is correct; landing on the lax side is an incident.
+ */
+export declare function readUnrepresentablePolicy(libraryOptions: Record<string, unknown> | undefined): UnrepresentablePolicy;

package/dist/standard-schema/unrepresentable-rule-error.js

@@ -0,0 +1,43 @@
+"use strict";
+// ===========================================================================
+// L10 src/standard-schema/unrepresentable-rule-error.ts
+//
+// Meeting a declaration that cannot be written as JSON Schema throws, by
+// default.
+//
+// Dropping it silently is not on offer. What comes out of here gets USED FOR
+// VALIDATION by whoever receives it, so dropping a `.custom()` produces a
+// schema that admits values it must not — with no trace of the omission. The
+// missing constraint is discovered by the incident it causes.
+//
+// Anyone for whom dropping is fine — emitting for documentation or for a form
+// layout rather than for validation — can ask for it explicitly through
+// libraryOptions, which the spec provides for exactly this kind of agreement.
+// The point is that the lax choice is never the default, and that having made
+// it stays visible in the caller's code.
+// ===========================================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnrepresentableRuleError = void 0;
+exports.readUnrepresentablePolicy = readUnrepresentablePolicy;
+class UnrepresentableRuleError extends Error {
+    constructor(fieldPath, pluginName, reason) {
+        super(`"${fieldPath}" declares ${pluginName}, which Luq cannot express in ` +
+            `JSON Schema: ${reason}. Pass ` +
+            `libraryOptions: { unrepresentable: "omit" } to drop it instead — ` +
+            `the emitted schema then accepts values this validator rejects.`);
+        this.fieldPath = fieldPath;
+        this.pluginName = pluginName;
+        this.reason = reason;
+        this.name = "UnrepresentableRuleError";
+    }
+}
+exports.UnrepresentableRuleError = UnrepresentableRuleError;
+/**
+ * Reads the policy out of `libraryOptions`.
+ *
+ * An unrecognised value falls to throw. A misspelled `omit` landing on the
+ * strict side is correct; landing on the lax side is an incident.
+ */
+function readUnrepresentablePolicy(libraryOptions) {
+    return libraryOptions?.["unrepresentable"] === "omit" ? "omit" : "throw";
+}

package/dist/standard-schema/unrepresentable-rule-error.mjs

@@ -0,0 +1,38 @@
+// ===========================================================================
+// L10 src/standard-schema/unrepresentable-rule-error.ts
+//
+// Meeting a declaration that cannot be written as JSON Schema throws, by
+// default.
+//
+// Dropping it silently is not on offer. What comes out of here gets USED FOR
+// VALIDATION by whoever receives it, so dropping a `.custom()` produces a
+// schema that admits values it must not — with no trace of the omission. The
+// missing constraint is discovered by the incident it causes.
+//
+// Anyone for whom dropping is fine — emitting for documentation or for a form
+// layout rather than for validation — can ask for it explicitly through
+// libraryOptions, which the spec provides for exactly this kind of agreement.
+// The point is that the lax choice is never the default, and that having made
+// it stays visible in the caller's code.
+// ===========================================================================
+export class UnrepresentableRuleError extends Error {
+    constructor(fieldPath, pluginName, reason) {
+        super(`"${fieldPath}" declares ${pluginName}, which Luq cannot express in ` +
+            `JSON Schema: ${reason}. Pass ` +
+            `libraryOptions: { unrepresentable: "omit" } to drop it instead — ` +
+            `the emitted schema then accepts values this validator rejects.`);
+        this.fieldPath = fieldPath;
+        this.pluginName = pluginName;
+        this.reason = reason;
+        this.name = "UnrepresentableRuleError";
+    }
+}
+/**
+ * Reads the policy out of `libraryOptions`.
+ *
+ * An unrecognised value falls to throw. A misspelled `omit` landing on the
+ * strict side is correct; landing on the lax side is an incident.
+ */
+export function readUnrepresentablePolicy(libraryOptions) {
+    return libraryOptions?.["unrepresentable"] === "omit" ? "omit" : "throw";
+}

package/dist/types/index.d.ts

@@ -44,12 +44,12 @@ export type CheckOutcome = {
 export declare const PASS: CheckOutcome;
 export declare function fail(detail: IssueDetail): CheckOutcome;
 /**
- * クロスフィールドの判定が返せるもの。真偽だけでも、メッセージ付きでもよい。
+ * What a cross-field check may answer: a boolean, or a boolean with a message.
  *
- * ここ (L0) にあるのは、チェーン層が `stitch` の呼び出し側の型を組むときに
- * 参照するからである。プラグイン (L7) に置いたままだと L3 -> L7 の import に
- * なり、層が逆流する。プラグイン側の `StitchOutcome` はこれの別名で、
- * 公開名は変えていない。
+ * It lives at the bottom layer because the chain layer needs it to build the
+ * caller-facing type of `stitch`. Left in the plugin, that would be an import
+ * running outward from the chain, which no layer may do. The plugin's
+ * `StitchOutcome` is an alias of this one, so the public name is unchanged.
  */
 export interface CrossFieldOutcome {
     readonly valid: boolean;
@@ -79,14 +79,14 @@ export declare function isArray(value: unknown): value is readonly unknown[];
 export declare function isPlainObject(value: unknown): value is Record<string, unknown>;
 export declare function isStringArray(value: unknown): value is readonly string[];
 /**
- * 文字列の長さをコードポイントで数える。
+ * Counts a string's length in code points.
  *
- * `.length` は UTF-16 のコード単位を数えるので、絵文字や星域文字が 2 と数えられる。
- * JSON Schema §6.3.1 は minLength / maxLength をコードポイントで数えると定めており、
- * 利用者が「3文字」と書くときに期待するのもコードポイントのほう。
+ * `.length` counts UTF-16 code units, so an emoji or any astral character
+ * counts as two. JSON Schema §6.3.1 defines minLength / maxLength in code
+ * points, and code points are also what someone writing "three characters"
+ * means.
  *
- * 1.x は `.length` を使っていた (docs/legacy-spec/plugin-catalog-core.md が
- * 「暗黙の挙動で、まわりに落ちるテストがある。明示的な決定にすべき」と記録している)。
- * ここでその決定をした。星域文字を含む文字列では 1.x と判定が変わる。
+ * This is a deliberate decision, not an inherited one: strings containing
+ * astral characters are judged differently than under the legacy `.length`.
  */
 export declare function countCodePoints(value: string): number;

package/dist/types/index.js

@@ -28,15 +28,15 @@ function isStringArray(value) {
     return isArray(value) && value.every(isString);
 }
 /**
- * 文字列の長さをコードポイントで数える。
+ * Counts a string's length in code points.
  *
- * `.length` は UTF-16 のコード単位を数えるので、絵文字や星域文字が 2 と数えられる。
- * JSON Schema §6.3.1 は minLength / maxLength をコードポイントで数えると定めており、
- * 利用者が「3文字」と書くときに期待するのもコードポイントのほう。
+ * `.length` counts UTF-16 code units, so an emoji or any astral character
+ * counts as two. JSON Schema §6.3.1 defines minLength / maxLength in code
+ * points, and code points are also what someone writing "three characters"
+ * means.
  *
- * 1.x は `.length` を使っていた (docs/legacy-spec/plugin-catalog-core.md が
- * 「暗黙の挙動で、まわりに落ちるテストがある。明示的な決定にすべき」と記録している)。
- * ここでその決定をした。星域文字を含む文字列では 1.x と判定が変わる。
+ * This is a deliberate decision, not an inherited one: strings containing
+ * astral characters are judged differently than under the legacy `.length`.
  */
 function countCodePoints(value) {
     let count = 0;

package/dist/types/index.mjs

@@ -18,15 +18,15 @@ export function isStringArray(value) {
     return isArray(value) && value.every(isString);
 }
 /**
- * 文字列の長さをコードポイントで数える。
+ * Counts a string's length in code points.
  *
- * `.length` は UTF-16 のコード単位を数えるので、絵文字や星域文字が 2 と数えられる。
- * JSON Schema §6.3.1 は minLength / maxLength をコードポイントで数えると定めており、
- * 利用者が「3文字」と書くときに期待するのもコードポイントのほう。
+ * `.length` counts UTF-16 code units, so an emoji or any astral character
+ * counts as two. JSON Schema §6.3.1 defines minLength / maxLength in code
+ * points, and code points are also what someone writing "three characters"
+ * means.
  *
- * 1.x は `.length` を使っていた (docs/legacy-spec/plugin-catalog-core.md が
- * 「暗黙の挙動で、まわりに落ちるテストがある。明示的な決定にすべき」と記録している)。
- * ここでその決定をした。星域文字を含む文字列では 1.x と判定が変わる。
+ * This is a deliberate decision, not an inherited one: strings containing
+ * astral characters are judged differently than under the legacy `.length`.
  */
 export function countCodePoints(value) {
     let count = 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maroonedog/luq",
-  "version": "2.2.0",
+  "version": "2.3.1",
   "description": "Universal Model & API Definition Platform - TypeScript validation library evolving into cross-language code generation",
   "main": "dist/index.js",
   "module": "dist/index.mjs",