@maroonedog/luq 0.1.2-alpha → 2.1.0

package/dist/plugins/optional/optional.d.ts

@@ -0,0 +1,7 @@
+import type { MessageContextExtra, TypeName } from "../../types";
+import type { PresenceShift } from "../../plugin-kit/marker.types";
+export declare const optionalPlugin: import("../../plugin-kit/plugin-definition").PluginDefinition<"optional", "optional", readonly TypeName[], {
+    args: readonly [];
+    out: PresenceShift<"excludeNull">;
+    context: MessageContextExtra;
+}>;

package/dist/plugins/optional/optional.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.optionalPlugin = void 0;
+// ===========================================================================
+// L7  src/plugins/optional/optional.ts
+//
+// `.optional()` accepts a MISSING value and still rejects an explicit null:
+// legacy's optional returned false for null and said so in its message, and
+// that split between "not there" and "there, and null" is the whole point of
+// having both optional and nullable.
+//
+// The empty string is NOT absence here (emptyStringIsMissing: false), which is
+// why `.optional().min(3)` still judges "" — legacy did the same.
+// ===========================================================================
+const create_rule_1 = require("../../plugin-kit/create-rule");
+const plugin_definition_1 = require("../../plugin-kit/plugin-definition");
+const OPTIONAL_SLOTS = [
+    "string",
+    "number",
+    "boolean",
+    "date",
+    "array",
+    "tuple",
+    "object",
+    "union",
+    "any",
+];
+exports.optionalPlugin = (0, plugin_definition_1.definePlugin)()({
+    name: "optional",
+    method: "optional",
+    slots: OPTIONAL_SLOTS,
+    build: (ctx) => (0, create_rule_1.presence)({
+        code: ctx.code,
+        messageFactory: ctx.messageFactory,
+        severity: ctx.severity,
+        allowUndefined: true,
+        allowNull: false,
+        emptyStringIsMissing: false,
+        describe: (messageContext) => `${messageContext.path} cannot be null (use undefined for optional fields)`,
+        buildMessageContext: () => ({}),
+    }),
+});

package/dist/plugins/optional/optional.mjs

@@ -0,0 +1,39 @@
+// ===========================================================================
+// L7  src/plugins/optional/optional.ts
+//
+// `.optional()` accepts a MISSING value and still rejects an explicit null:
+// legacy's optional returned false for null and said so in its message, and
+// that split between "not there" and "there, and null" is the whole point of
+// having both optional and nullable.
+//
+// The empty string is NOT absence here (emptyStringIsMissing: false), which is
+// why `.optional().min(3)` still judges "" — legacy did the same.
+// ===========================================================================
+import { presence } from "../../plugin-kit/create-rule.mjs";
+import { definePlugin } from "../../plugin-kit/plugin-definition.mjs";
+const OPTIONAL_SLOTS = [
+    "string",
+    "number",
+    "boolean",
+    "date",
+    "array",
+    "tuple",
+    "object",
+    "union",
+    "any",
+];
+export const optionalPlugin = /*#__PURE__*/ definePlugin()({
+    name: "optional",
+    method: "optional",
+    slots: OPTIONAL_SLOTS,
+    build: (ctx) => presence({
+        code: ctx.code,
+        messageFactory: ctx.messageFactory,
+        severity: ctx.severity,
+        allowUndefined: true,
+        allowNull: false,
+        emptyStringIsMissing: false,
+        describe: (messageContext) => `${messageContext.path} cannot be null (use undefined for optional fields)`,
+        buildMessageContext: () => ({}),
+    }),
+});

package/dist/plugins/optional-if/index.d.ts

@@ -0,0 +1 @@
+export { optionalIfPlugin, type OptionalIfExtra } from "./optional-if";

package/dist/plugins/optional-if/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.optionalIfPlugin = void 0;
+var optional_if_1 = require("./optional-if");
+Object.defineProperty(exports, "optionalIfPlugin", { enumerable: true, get: function () { return optional_if_1.optionalIfPlugin; } });

package/dist/plugins/optional-if/index.mjs

@@ -0,0 +1 @@
+export { optionalIfPlugin } from "./optional-if.mjs";

package/dist/plugins/optional-if/optional-if.d.ts

@@ -0,0 +1,11 @@
+import type { TypeName } from "../../types";
+import type { RootPredicate, Unchanged } from "../../plugin-kit/marker.types";
+/** Legacy OptionalIfContext: the condition that made the field optional. */
+export interface OptionalIfExtra {
+    readonly condition: boolean;
+}
+export declare const optionalIfPlugin: import("../../plugin-kit/plugin-definition").PluginDefinition<"optionalIf", "optionalIf", readonly TypeName[], {
+    args: readonly [when: RootPredicate];
+    out: Unchanged;
+    context: OptionalIfExtra;
+}>;

package/dist/plugins/optional-if/optional-if.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.optionalIfPlugin = void 0;
+const create_conditional_presence_1 = require("../../plugin-kit/create-conditional-presence");
+const plugin_definition_1 = require("../../plugin-kit/plugin-definition");
+const OPTIONAL_IF_SLOTS = [
+    "string",
+    "number",
+    "boolean",
+    "date",
+    "array",
+    "tuple",
+    "object",
+    "union",
+    "any",
+];
+exports.optionalIfPlugin = (0, plugin_definition_1.definePlugin)()({
+    name: "optionalIf",
+    method: "optionalIf",
+    slots: OPTIONAL_IF_SLOTS,
+    build: (ctx, when) => (0, create_conditional_presence_1.conditionalPresence)({
+        code: ctx.code,
+        messageFactory: ctx.messageFactory,
+        severity: ctx.severity,
+        when,
+        whenMet: create_conditional_presence_1.PERMITS_ABSENCE,
+        whenUnmet: create_conditional_presence_1.REQUIRES_A_VALUE,
+        describe: () => "Field is optional when condition is met",
+        buildMessageContext: () => ({ condition: false }),
+    }),
+});

package/dist/plugins/optional-if/optional-if.mjs

@@ -0,0 +1,28 @@
+import { PERMITS_ABSENCE, REQUIRES_A_VALUE, conditionalPresence, } from "../../plugin-kit/create-conditional-presence.mjs";
+import { definePlugin } from "../../plugin-kit/plugin-definition.mjs";
+const OPTIONAL_IF_SLOTS = [
+    "string",
+    "number",
+    "boolean",
+    "date",
+    "array",
+    "tuple",
+    "object",
+    "union",
+    "any",
+];
+export const optionalIfPlugin = /*#__PURE__*/ definePlugin()({
+    name: "optionalIf",
+    method: "optionalIf",
+    slots: OPTIONAL_IF_SLOTS,
+    build: (ctx, when) => conditionalPresence({
+        code: ctx.code,
+        messageFactory: ctx.messageFactory,
+        severity: ctx.severity,
+        when,
+        whenMet: PERMITS_ABSENCE,
+        whenUnmet: REQUIRES_A_VALUE,
+        describe: () => "Field is optional when condition is met",
+        buildMessageContext: () => ({ condition: false }),
+    }),
+});

package/dist/plugins/optional.d.ts

@@ -1,35 +1 @@
-/**
- * @luq-plugin
- * @name optional
- * @category standard
- * @description Allows a field to be undefined (but not null or empty string)
- * @allowedTypes ["string", "number", "boolean", "array", "object", "date", "union"]
- * @example
- * ```typescript
- * // Basic usage - field can be undefined
- * const validator = Builder()
- *   .use(optionalPlugin)
- *   .for<UserProfile>()
- *   .v("nickname", (b) => b.string.optional().min(3))
- *   .v("age", (b) => b.number.optional().min(0))
- *   .build();
- *
- * // Arrays and objects can be optional
- * builder.v("hobbies", b => b.array.optional().minLength(1))
- * builder.v("settings", b => b.object.optional())
- * ```
- * @params
- * No parameters - this is a modifier plugin
- * @returns Validation function that returns true and skips further validation if value is undefined
- * @customError
- * This plugin does not generate errors - it allows undefined values
- * @since 0.1.0-alpha
- */
-export declare const optionalPlugin: import("../index").TypedPlugin<"optional", "optional", () => {
-    check: (value: any) => boolean;
-    code: string;
-    getErrorMessage: (value: any, path: string) => string;
-    params: any[];
-    isOptional: boolean;
-    skipForUndefined: boolean;
-}, readonly ["string", "number", "boolean", "array", "object", "date", "union"], "validator", "standard">;
+export * from "./optional/index";

package/dist/plugins/optional.js

@@ -1 +1,2 @@
-"use strict";var s=Object.defineProperty;var p=Object.getOwnPropertyDescriptor;var T=Object.getOwnPropertyNames;var d=Object.prototype.hasOwnProperty;var g=(e,n)=>{for(var a in n)s(e,a,{get:n[a],enumerable:!0})},y=(e,n,a,l)=>{if(n&&typeof n=="object"||typeof n=="function")for(let r of T(n))!d.call(e,r)&&r!==a&&s(e,r,{get:()=>n[r],enumerable:!(l=p(n,r))||l.enumerable});return e};var c=e=>y(s({},"__esModule",{value:!0}),e);var I={};g(I,{optionalPlugin:()=>h});module.exports=c(I);var f=(e,n,a,l)=>{let o=(t=>(...i)=>{let m=t(...i);return m&&typeof m=="object"&&"check"in m?{...m,pluginName:l}:m})(a);switch(e){case"conditional":return(t,...i)=>o(t,...i);case"fieldReference":return(t,...i)=>o(t,...i);case"multiFieldReference":return o;case"transform":return t=>o(t);case"arrayElement":return(t,...i)=>o(t,...i);case"context":return t=>o(t);default:return o}};function u(e){let{name:n,methodName:a,allowedTypes:l,category:r,impl:o}=e;return{name:n,methodName:a,allowedTypes:l,category:r,create:()=>f(r,a,o,n)}}var C=Object.freeze({valid:!0,__skipFurtherValidation:!0}),N=["string","number","boolean","array","object","date","union"],h=u({name:"optional",methodName:"optional",allowedTypes:N,category:"standard",impl:()=>({check:e=>e!==null,code:"optional",getErrorMessage:(e,n)=>e===null?`${n} cannot be null (use undefined for optional fields)`:"Optional validation error (should not happen)",params:[],isOptional:!0,skipForUndefined:!0})});0&&(module.exports={optionalPlugin});
+"use strict";
+module.exports = require("./optional/index");

package/dist/plugins/optional.mjs

@@ -1 +1 @@
-var u=(t,r,i,l)=>{let n=(e=>(...a)=>{let o=e(...a);return o&&typeof o=="object"&&"check"in o?{...o,pluginName:l}:o})(i);switch(t){case"conditional":return(e,...a)=>n(e,...a);case"fieldReference":return(e,...a)=>n(e,...a);case"multiFieldReference":return n;case"transform":return e=>n(e);case"arrayElement":return(e,...a)=>n(e,...a);case"context":return e=>n(e);default:return n}};function s(t){let{name:r,methodName:i,allowedTypes:l,category:m,impl:n}=t;return{name:r,methodName:i,allowedTypes:l,category:m,create:()=>u(m,i,n,r)}}var g=Object.freeze({valid:!0,__skipFurtherValidation:!0}),p=["string","number","boolean","array","object","date","union"],y=s({name:"optional",methodName:"optional",allowedTypes:p,category:"standard",impl:()=>({check:t=>t!==null,code:"optional",getErrorMessage:(t,r)=>t===null?`${r} cannot be null (use undefined for optional fields)`:"Optional validation error (should not happen)",params:[],isOptional:!0,skipForUndefined:!0})});export{y as optionalPlugin};
+export * from "./optional/index.mjs";

package/dist/plugins/optionalIf.d.ts

@@ -0,0 +1 @@
+export * from "./optional-if/index";

package/dist/plugins/optionalIf.js

@@ -0,0 +1,2 @@
+"use strict";
+module.exports = require("./optional-if/index");

package/dist/plugins/optionalIf.mjs

@@ -0,0 +1 @@
+export * from "./optional-if/index.mjs";

package/dist/plugins/or-fail/index.d.ts

@@ -0,0 +1 @@
+export { orFailPlugin } from "./or-fail";

package/dist/plugins/or-fail/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.orFailPlugin = void 0;
+var or_fail_1 = require("./or-fail");
+Object.defineProperty(exports, "orFailPlugin", { enumerable: true, get: function () { return or_fail_1.orFailPlugin; } });

package/dist/plugins/or-fail/index.mjs

@@ -0,0 +1 @@
+export { orFailPlugin } from "./or-fail.mjs";

package/dist/plugins/or-fail/or-fail.d.ts

@@ -0,0 +1,7 @@
+import { type MessageContextExtra, type TypeName } from "../../types";
+import type { RootPredicate, Unchanged } from "../../plugin-kit/marker.types";
+export declare const orFailPlugin: import("../../plugin-kit/plugin-definition").PluginDefinition<"orFail", "orFail", readonly TypeName[], {
+    args: readonly [when: RootPredicate];
+    out: Unchanged;
+    context: MessageContextExtra;
+}>;

package/dist/plugins/or-fail/or-fail.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.orFailPlugin = void 0;
+// ===========================================================================
+// L7  src/plugins/or-fail/or-fail.ts — the negative gate.
+//
+// "If this condition holds, the field must not carry a value, whatever the
+// value is." Deprecated fields, debug fields that must not reach production,
+// fields a role or a feature flag forbids.
+//
+// Legacy took a raw `message` string option next to messageFactory. There is
+// one message channel now — options.messageFactory — so a constant message is
+// `{ messageFactory: () => "..." }` and there is no second precedence rule to
+// remember.
+// ===========================================================================
+const types_1 = require("../../types");
+const create_rule_1 = require("../../plugin-kit/create-rule");
+const plugin_definition_1 = require("../../plugin-kit/plugin-definition");
+const OR_FAIL_SLOTS = [
+    "string",
+    "number",
+    "boolean",
+    "date",
+    "array",
+    "tuple",
+    "object",
+    "union",
+    "any",
+];
+exports.orFailPlugin = (0, plugin_definition_1.definePlugin)()({
+    name: "orFail",
+    method: "orFail",
+    slots: OR_FAIL_SLOTS,
+    build: (ctx, when) => (0, create_rule_1.check)({
+        code: ctx.code,
+        messageFactory: ctx.messageFactory,
+        severity: ctx.severity,
+        run: (value, ruleContext) => when(ruleContext.root, ruleContext.item)
+            ? (0, types_1.fail)({ actual: value })
+            : types_1.PASS,
+        describe: () => "Validation failed",
+        buildMessageContext: () => ({}),
+    }),
+});

package/dist/plugins/or-fail/or-fail.mjs

@@ -0,0 +1,41 @@
+// ===========================================================================
+// L7  src/plugins/or-fail/or-fail.ts — the negative gate.
+//
+// "If this condition holds, the field must not carry a value, whatever the
+// value is." Deprecated fields, debug fields that must not reach production,
+// fields a role or a feature flag forbids.
+//
+// Legacy took a raw `message` string option next to messageFactory. There is
+// one message channel now — options.messageFactory — so a constant message is
+// `{ messageFactory: () => "..." }` and there is no second precedence rule to
+// remember.
+// ===========================================================================
+import { PASS, fail, } from "../../types/index.mjs";
+import { check } from "../../plugin-kit/create-rule.mjs";
+import { definePlugin } from "../../plugin-kit/plugin-definition.mjs";
+const OR_FAIL_SLOTS = [
+    "string",
+    "number",
+    "boolean",
+    "date",
+    "array",
+    "tuple",
+    "object",
+    "union",
+    "any",
+];
+export const orFailPlugin = /*#__PURE__*/ definePlugin()({
+    name: "orFail",
+    method: "orFail",
+    slots: OR_FAIL_SLOTS,
+    build: (ctx, when) => check({
+        code: ctx.code,
+        messageFactory: ctx.messageFactory,
+        severity: ctx.severity,
+        run: (value, ruleContext) => when(ruleContext.root, ruleContext.item)
+            ? fail({ actual: value })
+            : PASS,
+        describe: () => "Validation failed",
+        buildMessageContext: () => ({}),
+    }),
+});

package/dist/plugins/orFail.d.ts

@@ -0,0 +1 @@
+export * from "./or-fail/index";

package/dist/plugins/orFail.js

@@ -0,0 +1,2 @@
+"use strict";
+module.exports = require("./or-fail/index");

package/dist/plugins/orFail.mjs

@@ -0,0 +1 @@
+export * from "./or-fail/index.mjs";

package/dist/plugins/read-only/index.d.ts

@@ -0,0 +1 @@
+export { readOnlyPlugin } from "./read-only";

package/dist/plugins/read-only/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readOnlyPlugin = void 0;
+var read_only_1 = require("./read-only");
+Object.defineProperty(exports, "readOnlyPlugin", { enumerable: true, get: function () { return read_only_1.readOnlyPlugin; } });

package/dist/plugins/read-only/index.mjs

@@ -0,0 +1 @@
+export { readOnlyPlugin } from "./read-only.mjs";

package/dist/plugins/read-only/read-only.d.ts

@@ -0,0 +1,7 @@
+import type { MessageContextExtra } from "../../types";
+import type { Unchanged } from "../../plugin-kit/marker.types";
+export declare const readOnlyPlugin: import("../../plugin-kit/plugin-definition").PluginDefinition<"readOnly", "readOnly", readonly ["string", "number", "boolean", "date", "array", "object"], {
+    args: readonly [];
+    out: Unchanged;
+    context: MessageContextExtra;
+}>;

package/dist/plugins/read-only/read-only.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readOnlyPlugin = void 0;
+// ===========================================================================
+// L7  src/plugins/read-only/read-only.ts
+// JSON Schema's readOnly as an access check: on a WRITE that updates an
+// existing record, a read-only field may not carry a value.
+//
+// 1.x defined this and writeOnly in ONE file and exported only the first, so
+// `.writeOnly()` was unreachable even though the two keywords are peers
+// (docs/legacy-spec/public-api-surface.md). They are two directories now.
+//
+// The operation arrives on the same channel every other contextual plugin
+// reads, RuleContext.external, instead of 1.x's third `context` argument that
+// no execution path ever supplied.
+// ===========================================================================
+const types_1 = require("../../types");
+const create_rule_1 = require("../../plugin-kit/create-rule");
+const plugin_definition_1 = require("../../plugin-kit/plugin-definition");
+const external_context_1 = require("../../plugin-kit/external-context");
+const ACCESS_SLOTS = [
+    "string",
+    "number",
+    "boolean",
+    "date",
+    "array",
+    "object",
+];
+/** 1.x's default when the context says nothing is "write". */
+function isWriteOperation(context) {
+    return context["operation"] !== "read";
+}
+exports.readOnlyPlugin = (0, plugin_definition_1.definePlugin)()({
+    name: "readOnly",
+    method: "readOnly",
+    slots: ACCESS_SLOTS,
+    build: (ctx) => (0, create_rule_1.check)({
+        code: ctx.code,
+        messageFactory: ctx.messageFactory,
+        severity: ctx.severity,
+        run: (value, runCtx) => {
+            const external = (0, external_context_1.readExternalContext)(runCtx, types_1.isPlainObject);
+            if (external === undefined || !isWriteOperation(external))
+                return types_1.PASS;
+            if (external["isUpdate"] !== true || value === undefined)
+                return types_1.PASS;
+            return (0, types_1.fail)({ actual: value });
+        },
+        describe: (_detail, msgCtx) => `${msgCtx.path} is read-only and cannot be modified`,
+        buildMessageContext: () => ({}),
+    }),
+});

package/dist/plugins/read-only/read-only.mjs

@@ -0,0 +1,49 @@
+// ===========================================================================
+// L7  src/plugins/read-only/read-only.ts
+// JSON Schema's readOnly as an access check: on a WRITE that updates an
+// existing record, a read-only field may not carry a value.
+//
+// 1.x defined this and writeOnly in ONE file and exported only the first, so
+// `.writeOnly()` was unreachable even though the two keywords are peers
+// (docs/legacy-spec/public-api-surface.md). They are two directories now.
+//
+// The operation arrives on the same channel every other contextual plugin
+// reads, RuleContext.external, instead of 1.x's third `context` argument that
+// no execution path ever supplied.
+// ===========================================================================
+import { PASS, fail, isPlainObject } from "../../types/index.mjs";
+import { check } from "../../plugin-kit/create-rule.mjs";
+import { definePlugin } from "../../plugin-kit/plugin-definition.mjs";
+import { readExternalContext } from "../../plugin-kit/external-context.mjs";
+const ACCESS_SLOTS = [
+    "string",
+    "number",
+    "boolean",
+    "date",
+    "array",
+    "object",
+];
+/** 1.x's default when the context says nothing is "write". */
+function isWriteOperation(context) {
+    return context["operation"] !== "read";
+}
+export const readOnlyPlugin = /*#__PURE__*/ definePlugin()({
+    name: "readOnly",
+    method: "readOnly",
+    slots: ACCESS_SLOTS,
+    build: (ctx) => check({
+        code: ctx.code,
+        messageFactory: ctx.messageFactory,
+        severity: ctx.severity,
+        run: (value, runCtx) => {
+            const external = readExternalContext(runCtx, isPlainObject);
+            if (external === undefined || !isWriteOperation(external))
+                return PASS;
+            if (external["isUpdate"] !== true || value === undefined)
+                return PASS;
+            return fail({ actual: value });
+        },
+        describe: (_detail, msgCtx) => `${msgCtx.path} is read-only and cannot be modified`,
+        buildMessageContext: () => ({}),
+    }),
+});

package/dist/plugins/readOnly.d.ts

@@ -0,0 +1 @@
+export * from "./read-only/index";

package/dist/plugins/readOnly.js

@@ -0,0 +1,2 @@
+"use strict";
+module.exports = require("./read-only/index");

package/dist/plugins/readOnly.mjs

@@ -0,0 +1 @@
+export * from "./read-only/index.mjs";

package/dist/plugins/readOnlyWriteOnly.d.ts

@@ -1,48 +1 @@
-/**
- * @luq-plugin
- * @name readOnlyWriteOnly
- * @category context
- * @description Validates fields based on read-only or write-only context
- * @allowedTypes ["string", "number", "boolean", "date", "array", "object"]
- * @example
- * ```typescript
- * // Read-only field (should not be modified after creation)
- * const validator = Builder()
- *   .use(readOnlyWriteOnlyPlugin)
- *   .for<{ id: string; name: string; }>()
- *   .v("id", (b) => b.string.readOnly())
- *   .v("name", (b) => b.string.required())
- *   .build();
- *
- * // Write-only field (e.g., password that shouldn't be read back)
- * builder.v("password", b => b.string.writeOnly())
- *
- * // With operation context
- * const result = validator.validate(data, {
- *   context: { operation: "read" } // or "write"
- * });
- * ```
- * @params
- * - mode?: "readOnly" | "writeOnly" - The access mode for the field
- * - options?: { errorMessage?: string } - Optional configuration
- * @returns Validation function that checks field access based on context
- * @since 0.1.0-alpha
- */
-export interface ReadOnlyWriteOnlyOptions {
-    /** Custom error message */
-    errorMessage?: string;
-    /** Whether to skip validation entirely for inaccessible fields */
-    skipValidation?: boolean;
-}
-export declare const readOnlyWriteOnlyPlugin: import("../index").TypedPlugin<"readOnlyWriteOnly", "readOnly", (options?: ReadOnlyWriteOnlyOptions) => {
-    check: (value: any, allValues: any, context?: any) => boolean;
-    code: string;
-    getErrorMessage: (value: any, path: string) => string;
-    params: (string | ReadOnlyWriteOnlyOptions)[];
-}, readonly ["string", "number", "boolean", "date", "array", "object"], "validator", "context">;
-export declare const writeOnlyPlugin: import("../index").TypedPlugin<"writeOnly", "writeOnly", (options?: ReadOnlyWriteOnlyOptions) => {
-    check: (value: any, allValues: any, context?: any) => boolean;
-    code: string;
-    getErrorMessage: (value: any, path: string) => string;
-    params: (string | ReadOnlyWriteOnlyOptions)[];
-}, readonly ["string", "number", "boolean", "date", "array", "object"], "validator", "context">;
+export * from "../subpath-aliases/read-only-write-only";

package/dist/plugins/readOnlyWriteOnly.js

@@ -1 +1,2 @@
-"use strict";var m=Object.defineProperty;var u=Object.getOwnPropertyDescriptor;var T=Object.getOwnPropertyNames;var d=Object.prototype.hasOwnProperty;var y=(n,e)=>{for(var t in e)m(n,t,{get:e[t],enumerable:!0})},g=(n,e,t,a)=>{if(e&&typeof e=="object"||typeof e=="function")for(let r of T(e))!d.call(n,r)&&r!==t&&m(n,r,{get:()=>e[r],enumerable:!(a=u(e,r))||a.enumerable});return n};var c=n=>g(m({},"__esModule",{value:!0}),n);var h={};y(h,{readOnlyWriteOnlyPlugin:()=>N,writeOnlyPlugin:()=>x});module.exports=c(h);var f=(n,e,t,a)=>{let i=(o=>(...l)=>{let s=o(...l);return s&&typeof s=="object"&&"check"in s?{...s,pluginName:a}:s})(t);switch(n){case"conditional":return(o,...l)=>i(o,...l);case"fieldReference":return(o,...l)=>i(o,...l);case"multiFieldReference":return i;case"transform":return o=>i(o);case"arrayElement":return(o,...l)=>i(o,...l);case"context":return o=>i(o);default:return i}};function p(n){let{name:e,methodName:t,allowedTypes:a,category:r,impl:i}=n;return{name:e,methodName:t,allowedTypes:a,category:r,create:()=>f(r,t,i,e)}}var N=p({name:"readOnlyWriteOnly",methodName:"readOnly",allowedTypes:["string","number","boolean","date","array","object"],category:"context",impl:(n={})=>({check:(e,t,a)=>!((a?.operation||"write")==="write"&&e!==void 0&&a?.isUpdate),code:"READ_ONLY",getErrorMessage:(e,t)=>n.errorMessage||`${t} is read-only and cannot be modified`,params:["readOnly",n]})}),x=p({name:"writeOnly",methodName:"writeOnly",allowedTypes:["string","number","boolean","date","array","object"],category:"context",impl:(n={})=>({check:(e,t,a)=>!((a?.operation||"write")==="read"&&e!==void 0),code:"WRITE_ONLY",getErrorMessage:(e,t)=>n.errorMessage||`${t} is write-only and cannot be read`,params:["writeOnly",n]})});0&&(module.exports={readOnlyWriteOnlyPlugin,writeOnlyPlugin});
+"use strict";
+module.exports = require("../subpath-aliases/read-only-write-only");

package/dist/plugins/readOnlyWriteOnly.mjs

@@ -1 +1 @@
-var p=(t,a,n,o)=>{let r=(e=>(...i)=>{let s=e(...i);return s&&typeof s=="object"&&"check"in s?{...s,pluginName:o}:s})(n);switch(t){case"conditional":return(e,...i)=>r(e,...i);case"fieldReference":return(e,...i)=>r(e,...i);case"multiFieldReference":return r;case"transform":return e=>r(e);case"arrayElement":return(e,...i)=>r(e,...i);case"context":return e=>r(e);default:return r}};function m(t){let{name:a,methodName:n,allowedTypes:o,category:l,impl:r}=t;return{name:a,methodName:n,allowedTypes:o,category:l,create:()=>p(l,n,r,a)}}var d=m({name:"readOnlyWriteOnly",methodName:"readOnly",allowedTypes:["string","number","boolean","date","array","object"],category:"context",impl:(t={})=>({check:(a,n,o)=>!((o?.operation||"write")==="write"&&a!==void 0&&o?.isUpdate),code:"READ_ONLY",getErrorMessage:(a,n)=>t.errorMessage||`${n} is read-only and cannot be modified`,params:["readOnly",t]})}),y=m({name:"writeOnly",methodName:"writeOnly",allowedTypes:["string","number","boolean","date","array","object"],category:"context",impl:(t={})=>({check:(a,n,o)=>!((o?.operation||"write")==="read"&&a!==void 0),code:"WRITE_ONLY",getErrorMessage:(a,n)=>t.errorMessage||`${n} is write-only and cannot be read`,params:["writeOnly",t]})});export{d as readOnlyWriteOnlyPlugin,y as writeOnlyPlugin};
+export * from "../subpath-aliases/read-only-write-only.mjs";

package/dist/plugins/required/index.d.ts

@@ -0,0 +1 @@
+export { requiredPlugin } from "./required";

package/dist/plugins/required/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requiredPlugin = void 0;
+var required_1 = require("./required");
+Object.defineProperty(exports, "requiredPlugin", { enumerable: true, get: function () { return required_1.requiredPlugin; } });

package/dist/plugins/required/index.mjs

@@ -0,0 +1 @@
+export { requiredPlugin } from "./required.mjs";

package/dist/plugins/required/required.d.ts

@@ -0,0 +1,7 @@
+import type { MessageContextExtra, TypeName } from "../../types";
+import type { PresenceShift } from "../../plugin-kit/marker.types";
+export declare const requiredPlugin: import("../../plugin-kit/plugin-definition").PluginDefinition<"required", "required", readonly TypeName[], {
+    args: readonly [];
+    out: PresenceShift<"excludeMissing">;
+    context: MessageContextExtra;
+}>;

package/dist/plugins/required/required.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requiredPlugin = void 0;
+// ===========================================================================
+// L7  src/plugins/required/required.ts
+//
+// `out` is a PresenceShift, so RuleForOut demands a PresenceRule: the TYPE the
+// chain carries afterwards and the RUNTIME policy the field gets come from the
+// same declaration and cannot drift apart.
+//
+// Legacy emptiness is carried over verbatim: undefined, null and "" are
+// absent; 0, false, [] and {} are present. That is a deliberate form-oriented
+// choice users depend on (legacy-spec/plugin-catalog-core.md).
+// ===========================================================================
+const create_rule_1 = require("../../plugin-kit/create-rule");
+const plugin_definition_1 = require("../../plugin-kit/plugin-definition");
+const REQUIRED_SLOTS = [
+    "string",
+    "number",
+    "boolean",
+    "date",
+    "array",
+    "tuple",
+    "object",
+    "union",
+    "any",
+];
+exports.requiredPlugin = (0, plugin_definition_1.definePlugin)()({
+    name: "required",
+    method: "required",
+    slots: REQUIRED_SLOTS,
+    build: (ctx) => (0, create_rule_1.presence)({
+        code: ctx.code,
+        messageFactory: ctx.messageFactory,
+        severity: ctx.severity,
+        allowUndefined: false,
+        allowNull: false,
+        emptyStringIsMissing: true,
+        describe: (messageContext) => `${messageContext.path} is required`,
+        buildMessageContext: () => ({}),
+    }),
+});