@loomcli/validators 0.0.0 → 0.6.0

package/dist/probe.js

@@ -0,0 +1,66 @@
+import { constants } from 'node:fs';
+import { access, stat } from 'node:fs/promises';
+/** The probe failures that are a verdict about the operator's path rather than a broken host. */
+const verdicts = new Set([
+    'ENOENT',
+    'ENOTDIR',
+    'EACCES',
+    'EPERM',
+    'ELOOP',
+    'ENAMETOOLONG',
+    'EINVAL',
+]);
+function codeOf(error) {
+    return error instanceof Error && 'code' in error && typeof error.code === 'string'
+        ? error.code
+        : undefined;
+}
+/** Runs one probe, reading a verdict failure as `false` and rethrowing any other failure. */
+async function holds(probe) {
+    try {
+        return await probe();
+    }
+    catch (error) {
+        const code = codeOf(error);
+        if (code !== undefined && verdicts.has(code)) {
+            return false;
+        }
+        throw error;
+    }
+}
+function isKind(stats, kind) {
+    if (kind === 'file') {
+        return stats.isFile();
+    }
+    return kind === 'directory' ? stats.isDirectory() : true;
+}
+/** Whether an entry exists, following symbolic links, is of `kind`, and grants `mode`. */
+async function grants(target, kind, mode) {
+    const stats = await stat(target);
+    if (!isKind(stats, kind)) {
+        return false;
+    }
+    await access(target, mode);
+    return true;
+}
+async function readable(target, kind) {
+    return await holds(async () => await grants(target, kind, constants.R_OK));
+}
+/**
+ * Whether the process can write the entry, or create it when no entry exists: then the parent
+ * must be an existing directory the process can write. Nothing is created.
+ */
+async function writable(target, kind, parent) {
+    return await holds(async () => {
+        try {
+            return await grants(target, kind, constants.W_OK);
+        }
+        catch (error) {
+            if (codeOf(error) !== 'ENOENT') {
+                throw error;
+            }
+            return await grants(parent, 'directory', constants.W_OK);
+        }
+    });
+}
+export { holds, readable, writable };

package/dist/rules.d.ts

@@ -0,0 +1,32 @@
+import type { DiagnosticRule } from '@loomcli/core';
+/** A factory's options that are not a plain object. */
+declare const factoryOptions: DiagnosticRule;
+/** A `oneOf()` list that is not a list of distinct nonempty strings. */
+declare const oneOfValues: DiagnosticRule;
+/** A bound that is not a number of the kind its validator reads. */
+declare const boundValue: DiagnosticRule;
+/** A lower bound above its upper bound. */
+declare const boundsOrder: DiagnosticRule;
+/** A `url()` protocols list that is not a list of scheme names. */
+declare const urlProtocols: DiagnosticRule;
+/** A `path()` access or kind outside its set, or a kind with no access to narrow. */
+declare const pathCheck: DiagnosticRule;
+/** A `text()` pattern that JSON Schema cannot read as it is. */
+declare const textPattern: DiagnosticRule;
+/** A `text()` pattern without its sentence, or a sentence without a pattern. */
+declare const patternMessage: DiagnosticRule;
+/** An issue code outside the `<package>[/<subpath>...]/<kebab-case-rule>` grammar. */
+declare const issueCodeName: DiagnosticRule;
+/** An `issueCode()` config without a Standard Schema and a message function. */
+declare const issueCodeConfig: DiagnosticRule;
+/** An issue code schema that answers with a promise, throws, or answers with no result. */
+declare const issueCodeSchema: DiagnosticRule;
+/** Parameters an issue code's schema rejects. */
+declare const issueParameters: DiagnosticRule;
+/** A `createValidator()` definition without a parse function. */
+declare const validatorDefinition: DiagnosticRule;
+/** A `createValidator()` input schema that is not a plain object, or declares its own dialect. */
+declare const inputSchema: DiagnosticRule;
+/** A validator that read the validation context outside a Loom run. */
+declare const contextOutsideRun: DiagnosticRule;
+export { boundsOrder, boundValue, contextOutsideRun, factoryOptions, inputSchema, issueCodeConfig, issueCodeName, issueCodeSchema, issueParameters, oneOfValues, pathCheck, patternMessage, textPattern, urlProtocols, validatorDefinition, };

package/dist/rules.js

@@ -0,0 +1,86 @@
+import { diagnosticRule } from '@loomcli/core';
+/*
+ * The catalog's rules for the declaration faults its factories raise. Each is declared once here
+ * through the public diagnosticRule(), under the package's own name, as any third-party validator
+ * package declares its rules, and shared by every site that raises it.
+ */
+/** One rule of this package, named under the package as its issue codes are. */
+function catalogRule(name, definition) {
+    return diagnosticRule(`@loomcli/validators/${name}`, definition);
+}
+/** A factory's options that are not a plain object. */
+const factoryOptions = catalogRule('factory-options', {
+    explanation: 'A catalog factory reads its settings from one options object, so a value of any other kind leaves it no settings to read.',
+    headline: 'Options not an object',
+});
+/** A `oneOf()` list that is not a list of distinct nonempty strings. */
+const oneOfValues = catalogRule('one-of-values', {
+    explanation: 'oneOf() accepts a token equal to one of its values, and help, completion, and the published schema offer each value as a choice, so the list holds at least one value, each a distinct nonempty string.',
+    headline: 'Invalid oneOf values',
+});
+/** A bound that is not a number of the kind its validator reads. */
+const boundValue = catalogRule('bound-value', {
+    explanation: "A bound limits the values or the length a validator accepts, and the published schema carries it, so it is a number of the kind the validator reads: a safe integer for integer(), a finite number for number(), and a non-negative safe integer for text()'s lengths.",
+    headline: 'Invalid bound',
+});
+/** A lower bound above its upper bound. */
+const boundsOrder = catalogRule('bounds-order', {
+    explanation: 'A validator accepts what lies between its lower and its upper bound, both inclusive, so a lower bound above the upper one would reject every token.',
+    headline: 'Bounds out of order',
+});
+/** A `url()` protocols list that is not a list of scheme names. */
+const urlProtocols = catalogRule('url-protocols', {
+    explanation: 'url() accepts a URL whose scheme the list names and publishes the list as a pattern, so it holds at least one scheme name: a letter followed by letters, digits, +, -, or ., with no trailing colon.',
+    headline: 'Invalid url protocols',
+});
+/** A `path()` access or kind outside its set, or a kind with no access to narrow. */
+const pathCheck = catalogRule('path-check', {
+    explanation: 'path() reads the file system only to check an access, read or write, and kind narrows that check to a file, a directory, or any entry, so kind has no meaning without access.',
+    headline: 'Invalid path check',
+});
+/** A `text()` pattern that JSON Schema cannot read as it is. */
+const textPattern = catalogRule('invalid-pattern', {
+    explanation: 'text() publishes its pattern in the JSON Schema it serves, which reads a pattern under the u flag alone, so the pattern is a regular expression that compiles under u and carries no other flag.',
+    headline: 'Invalid pattern',
+});
+/** A `text()` pattern without its sentence, or a sentence without a pattern. */
+const patternMessage = catalogRule('pattern-message', {
+    explanation: 'Only the author can say what a pattern accepts, so text() takes a pattern together with one sentence that states it, and prints that sentence when a token does not match.',
+    headline: 'Pattern and message apart',
+});
+/** An issue code outside the `<package>[/<subpath>...]/<kebab-case-rule>` grammar. */
+const issueCodeName = catalogRule('issue-code-name', {
+    explanation: 'An issue code names the package that declares it and the one sentence it prints, so a view rewords that sentence by its code. It is a package name, any kebab-case subpath segments, and a kebab-case rule name, joined by /.',
+    headline: 'Invalid issue code',
+});
+/** An `issueCode()` config without a Standard Schema and a message function. */
+const issueCodeConfig = catalogRule('issue-code-config', {
+    explanation: "An issue code checks each issue's parameters with its schema and builds the issue's sentence from them with its message function, so its config holds both.",
+    headline: 'Invalid issue code config',
+});
+/** An issue code schema that answers with a promise, throws, or answers with no result. */
+const issueCodeSchema = catalogRule('issue-code-schema', {
+    explanation: "issue() and read() check an issue's parameters with the code's schema synchronously, while a validator builds the issue or a view reads it, so the schema returns its value or its issues, and neither throws nor answers with a promise.",
+    headline: 'Broken issue code schema',
+});
+/** Parameters an issue code's schema rejects. */
+const issueParameters = catalogRule('issue-parameters', {
+    explanation: "An issue carries parameters its code's schema accepts, so every view that reads them through read() gets the shape the code declares.",
+    headline: 'Issue parameters rejected',
+});
+/** A `createValidator()` definition without a parse function. */
+const validatorDefinition = catalogRule('validator-definition', {
+    explanation: 'createValidator() builds a Standard Schema value around one parse function that validates a raw string, so its definition is an object that holds that function.',
+    headline: 'Invalid validator definition',
+});
+/** A `createValidator()` input schema that is not a plain object, or declares its own dialect. */
+const inputSchema = catalogRule('input-schema', {
+    explanation: 'createValidator() publishes its input schema as draft 2020-12 JSON Schema and adds the $schema dialect itself, so inputSchema is a plain object with no $schema of its own.',
+    headline: 'Invalid input schema',
+});
+/** A validator that read the validation context outside a Loom run. */
+const contextOutsideRun = catalogRule('context-outside-run', {
+    explanation: 'Core attaches the validation context to each call it makes to a validator. A call from anywhere else, such as a unit test, carries none, so a validator that reads it runs inside an Application run.',
+    headline: 'Context outside a run',
+});
+export { boundsOrder, boundValue, contextOutsideRun, factoryOptions, inputSchema, issueCodeConfig, issueCodeName, issueCodeSchema, issueParameters, oneOfValues, pathCheck, patternMessage, textPattern, urlProtocols, validatorDefinition, };

package/dist/text.d.ts

@@ -0,0 +1,19 @@
+import type { Validator } from './create.js';
+/**
+ * The bounds on a token's length, and a pattern with the author's sentence for what it accepts.
+ * Only the author can say what a pattern accepts, so `message` comes with `pattern` or not at all.
+ */
+type TextOptions = {
+    minLength?: number;
+    maxLength?: number;
+} & ({
+    pattern?: undefined;
+    message?: undefined;
+} | {
+    pattern: RegExp;
+    message: string;
+});
+/** A string whose code-point length is within bounds and which the pattern matches, if any. */
+declare function text(options?: TextOptions): Validator<string>;
+export { text };
+export type { TextOptions };

package/dist/text.js

@@ -0,0 +1,152 @@
+import { textExactLengthIssue, textLengthRangeIssue, textMaxLengthIssue, textMinLengthIssue, textNonemptyIssue, textPatternIssue, } from './codes.js';
+import { createValidator } from './create.js';
+import { fault, readOptions } from './faults.js';
+import { reject } from './issues.js';
+import { boundsOrder, boundValue, patternMessage, textPattern } from './rules.js';
+const noLength = 0;
+const oneCharacter = 1;
+const defaultMinLength = 1;
+/** The `text()` call a fault marks one key of. */
+function textAt(call, key) {
+    return { ...call, mark: `0.${key}` };
+}
+function lengthOf(call, name, value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (typeof value !== 'number' || !Number.isSafeInteger(value) || value < noLength) {
+        throw fault(boundValue, textAt(call, name), {
+            correction: 'Supply a whole number of 0 or more.',
+            sentence: `text() ${name} is not a non-negative safe integer.`,
+        });
+    }
+    return value;
+}
+/** Faults on a pattern flag other than `u`, which JSON Schema has no way to state. */
+function checkFlags(call, pattern) {
+    const others = pattern.flags.replace('u', '');
+    if (others !== '') {
+        const noun = others.length === oneCharacter ? 'flag' : 'flags';
+        throw fault(textPattern, textAt(call, 'pattern'), {
+            correction: 'Supply a pattern with no flag other than u.',
+            sentence: `text() pattern carries the ${noun} ${others}.`,
+        });
+    }
+}
+/** The author's pattern recompiled under the `u` flag, as JSON Schema reads a `pattern`. */
+function patternOf(call, value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (!(value instanceof RegExp)) {
+        throw fault(textPattern, textAt(call, 'pattern'), {
+            correction: 'Supply a regular expression literal.',
+            sentence: 'text() pattern is not a RegExp.',
+        });
+    }
+    checkFlags(call, value);
+    try {
+        return new RegExp(value.source, 'u');
+    }
+    catch {
+        throw fault(textPattern, textAt(call, 'pattern'), {
+            correction: 'Supply a pattern that is valid with the u flag.',
+            sentence: 'text() pattern does not compile under the u flag.',
+        });
+    }
+}
+function messageOf(call, value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (typeof value !== 'string' || value === '') {
+        throw fault(patternMessage, textAt(call, 'message'), {
+            correction: 'Supply one sentence that states the expectation.',
+            sentence: 'text() message is not a nonempty string.',
+        });
+    }
+    return value;
+}
+/** The pattern rule, or undefined without a pattern; a pattern and a message each need the other. */
+function patternRule(call, pattern, message) {
+    if (pattern === undefined) {
+        if (message !== undefined) {
+            throw fault(patternMessage, textAt(call, 'message'), {
+                correction: 'Supply a pattern or leave out message.',
+                sentence: 'text() message has no pattern to describe.',
+            });
+        }
+        return undefined;
+    }
+    if (message === undefined) {
+        throw fault(patternMessage, textAt(call, 'pattern'), {
+            correction: 'Supply a message that states what the pattern accepts.',
+            sentence: 'text() pattern has no message to describe it.',
+        });
+    }
+    return { issue: textPatternIssue.issue({ message }), pattern };
+}
+/** The issue for bounds with a `maxLength`, where `min` is `minLength` after its default. */
+function boundedIssue(min, max) {
+    if (min === max) {
+        return textExactLengthIssue.issue({ length: min });
+    }
+    if (min === noLength) {
+        return textMaxLengthIssue.issue({ max });
+    }
+    return textLengthRangeIssue.issue({ max, min });
+}
+/** The length rule for the effective bounds, or undefined when every length passes. */
+function lengthRule(min, max) {
+    if (max !== undefined) {
+        return { fits: (count) => count >= min && count <= max, issue: boundedIssue(min, max) };
+    }
+    if (min === noLength) {
+        return undefined;
+    }
+    const issue = min === oneCharacter ? textNonemptyIssue.issue({}) : textMinLengthIssue.issue({ min });
+    return { fits: (count) => count >= min, issue };
+}
+/**
+ * The token's length in Unicode code points, as JSON Schema counts it.
+ * Under the `u` flag a dot matches one code point, a lone surrogate included, so replacing each
+ * match with one code unit leaves a string as long as the count.
+ */
+function codePoints(raw) {
+    return raw.replaceAll(/./gsu, '.').length;
+}
+/** A string whose code-point length is within bounds and which the pattern matches, if any. */
+function text(options) {
+    const declared = readOptions('text', options);
+    const call = { arguments: [options], factory: 'text' };
+    const minLength = lengthOf(call, 'minLength', declared.minLength) ?? defaultMinLength;
+    const maxLength = lengthOf(call, 'maxLength', declared.maxLength);
+    if (maxLength !== undefined && minLength > maxLength) {
+        // A minLength left to its default has no key to mark, so the maxLength below it is marked.
+        const key = declared.minLength === undefined ? 'maxLength' : 'minLength';
+        throw fault(boundsOrder, textAt(call, key), {
+            correction: 'Supply a minLength at or below maxLength.',
+            sentence: `text() minLength ${minLength} is above maxLength ${maxLength}.`,
+        });
+    }
+    const matching = patternRule(call, patternOf(call, declared.pattern), messageOf(call, declared.message));
+    const length = lengthRule(minLength, maxLength);
+    return createValidator({
+        inputSchema: {
+            type: 'string',
+            minLength,
+            ...(maxLength === undefined ? {} : { maxLength }),
+            ...(matching === undefined ? {} : { pattern: matching.pattern.source }),
+        },
+        parse: (raw) => {
+            if (length !== undefined && !length.fits(codePoints(raw))) {
+                return reject(length.issue);
+            }
+            if (matching !== undefined && !matching.pattern.test(raw)) {
+                return reject(matching.issue);
+            }
+            return { value: raw };
+        },
+    });
+}
+export { text };

package/dist/uri-grammar.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The RFC 3986 `URI` production, built from the RFC's own rule names:
+ * `scheme ":" hier-part [ "?" query ] [ "#" fragment ]`.
+ * Letters are spelled in both cases, so the expression needs no `i` flag.
+ */
+declare const uriPattern: RegExp;
+/** The RFC 3986 `scheme` production on its own, for checking a declared protocol. */
+declare const schemePattern: RegExp;
+export { schemePattern, uriPattern };

package/dist/uri-grammar.js

@@ -0,0 +1,42 @@
+/**
+ * The RFC 3986 `URI` production, built from the RFC's own rule names:
+ * `scheme ":" hier-part [ "?" query ] [ "#" fragment ]`.
+ * Letters are spelled in both cases, so the expression needs no `i` flag.
+ */
+const hex = '[0-9A-Fa-f]';
+const pctEncoded = `%${hex}{2}`;
+const unreserved = String.raw `A-Za-z0-9\-._~`;
+const subDelims = "!$&'()*+,;=";
+const pchar = `(?:[${unreserved}${subDelims}:@]|${pctEncoded})`;
+const scheme = String.raw `[A-Za-z][A-Za-z0-9+\-.]*`;
+const userinfo = `(?:[${unreserved}${subDelims}:]|${pctEncoded})*`;
+const decOctet = '(?:25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])';
+const ipv4 = String.raw `${decOctet}(?:\.${decOctet}){3}`;
+const h16 = `${hex}{1,4}`;
+const ls32 = `(?:${h16}:${h16}|${ipv4})`;
+const ipv6 = `(?:${[
+    `(?:${h16}:){6}${ls32}`,
+    `::(?:${h16}:){5}${ls32}`,
+    `(?:${h16})?::(?:${h16}:){4}${ls32}`,
+    `(?:(?:${h16}:){0,1}${h16})?::(?:${h16}:){3}${ls32}`,
+    `(?:(?:${h16}:){0,2}${h16})?::(?:${h16}:){2}${ls32}`,
+    `(?:(?:${h16}:){0,3}${h16})?::${h16}:${ls32}`,
+    `(?:(?:${h16}:){0,4}${h16})?::${ls32}`,
+    `(?:(?:${h16}:){0,5}${h16})?::${h16}`,
+    `(?:(?:${h16}:){0,6}${h16})?::`,
+].join('|')})`;
+const ipvFuture = String.raw `[vV]${hex}+\.[${unreserved}${subDelims}:]+`;
+const ipLiteral = String.raw `\[(?:${ipv6}|${ipvFuture})\]`;
+const regName = `(?:[${unreserved}${subDelims}]|${pctEncoded})*`;
+const host = `(?:${ipLiteral}|${ipv4}|${regName})`;
+const authority = `(?:${userinfo}@)?${host}(?::[0-9]*)?`;
+const pathAbempty = `(?:/${pchar}*)*`;
+const pathAbsolute = `/(?:${pchar}+(?:/${pchar}*)*)?`;
+const pathRootless = `${pchar}+(?:/${pchar}*)*`;
+// RFC 3986 also allows an empty path, which the published `uri` format refuses, so soundness drops it.
+const hierPart = `(?://${authority}${pathAbempty}|${pathAbsolute}|${pathRootless})`;
+const queryOrFragment = `(?:${pchar}|[/?])*`;
+const uriPattern = new RegExp(String.raw `^${scheme}:${hierPart}(?:\?${queryOrFragment})?(?:#${queryOrFragment})?$`, 'u');
+/** The RFC 3986 `scheme` production on its own, for checking a declared protocol. */
+const schemePattern = new RegExp(`^${scheme}$`, 'u');
+export { schemePattern, uriPattern };

package/dist/url.d.ts

@@ -0,0 +1,8 @@
+import type { Validator } from './create.js';
+interface UrlOptions {
+    protocols?: readonly [string, ...string[]];
+}
+/** An absolute RFC 3986 URI that the WHATWG parser also reads, optionally with a listed scheme. */
+declare function url(options?: UrlOptions): Validator<URL>;
+export { url };
+export type { UrlOptions };

package/dist/url.js

@@ -0,0 +1,74 @@
+import { urlIssue, urlSchemeIssue } from './codes.js';
+import { createValidator } from './create.js';
+import { fault, quote, readOptions } from './faults.js';
+import { reject } from './issues.js';
+import { urlProtocols } from './rules.js';
+import { schemePattern, uriPattern } from './uri-grammar.js';
+const empty = 0;
+/** The `protocols` a `url()` call declares, checked, and each fault marks it or one entry. */
+function protocolsOf(options, value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    const at = (mark) => ({ arguments: [options], factory: 'url', mark });
+    if (!Array.isArray(value)) {
+        throw fault(urlProtocols, at('0.protocols'), {
+            correction: 'Supply an array of scheme names.',
+            sentence: 'url() protocols is not an array.',
+        });
+    }
+    const items = value;
+    if (items.length === empty) {
+        throw fault(urlProtocols, at('0.protocols'), {
+            correction: 'List at least one scheme.',
+            sentence: 'url() protocols is empty.',
+        });
+    }
+    // `Array.from` reads a hole as `undefined`, so a sparse list faults instead of skipping it.
+    return Array.from(items, (item, index) => {
+        if (typeof item !== 'string' || !schemePattern.test(item)) {
+            throw fault(urlProtocols, at(`0.protocols.${String(index)}`), {
+                correction: 'List a letter followed by letters, digits, +, -, or ., with no trailing colon.',
+                sentence: `url() protocols lists ${quote(item)}, which is not a scheme name.`,
+            });
+        }
+        return item;
+    });
+}
+/**
+ * One scheme as a case-free pattern: each letter as a two-case class, `+` and `.` escaped.
+ * A hyphen stays bare, because the `u` flag JSON Schema patterns use refuses `\-` outside a class.
+ */
+function spellScheme(scheme) {
+    return scheme
+        .replaceAll(/[+.]/gu, String.raw `\$&`)
+        .replaceAll(/[A-Za-z]/gu, (letter) => `[${letter.toLowerCase()}${letter.toUpperCase()}]`);
+}
+/** The pattern that publishes a scheme list, anchored at the start and ending at the colon. */
+function schemesPattern(protocols) {
+    return `^(?:${protocols.map((protocol) => spellScheme(protocol)).join('|')}):`;
+}
+/** An absolute RFC 3986 URI that the WHATWG parser also reads, optionally with a listed scheme. */
+function url(options) {
+    const protocols = protocolsOf(options, readOptions('url', options).protocols);
+    // The WHATWG parser lowercases the scheme and ends `protocol` with a colon.
+    const listed = new Set(protocols?.map((protocol) => `${protocol.toLowerCase()}:`));
+    const issue = protocols === undefined ? urlIssue.issue({}) : urlSchemeIssue.issue({ protocols });
+    return createValidator({
+        inputSchema: {
+            type: 'string',
+            format: 'uri',
+            ...(protocols === undefined ? {} : { pattern: schemesPattern(protocols) }),
+        },
+        parse: (raw) => {
+            if (!uriPattern.test(raw) || !URL.canParse(raw)) {
+                return reject(issue);
+            }
+            const parsed = new URL(raw);
+            return protocols === undefined || listed.has(parsed.protocol)
+                ? { value: parsed }
+                : reject(issue);
+        },
+    });
+}
+export { url };

package/dist/uuid.d.ts

@@ -0,0 +1,4 @@
+import type { Validator } from './create.js';
+/** A UUID of any version in any letter case, read as lowercase so two spellings compare equal. */
+declare function uuid(): Validator<string>;
+export { uuid };

package/dist/uuid.js

@@ -0,0 +1,13 @@
+import { uuidIssue } from './codes.js';
+import { createValidator } from './create.js';
+import { reject } from './issues.js';
+const grouped = /^[0-9A-Fa-f]{8}-[0-9A-Fa-f]{4}-[0-9A-Fa-f]{4}-[0-9A-Fa-f]{4}-[0-9A-Fa-f]{12}$/u;
+/** A UUID of any version in any letter case, read as lowercase so two spellings compare equal. */
+function uuid() {
+    const issue = uuidIssue.issue({});
+    return createValidator({
+        inputSchema: { type: 'string', format: 'uuid' },
+        parse: (raw) => grouped.test(raw) ? { value: raw.toLowerCase() } : reject(issue),
+    });
+}
+export { uuid };

package/package.json

@@ -1,10 +1,32 @@
 {
   "name": "@loomcli/validators",
-  "version": "0.0.0",
-  "description": "Placeholder for the Loom CLI validator catalog. The first real release follows.",
+  "version": "0.6.0",
+  "description": "The Loom CLI validator catalog. Ships Standard Schema values for common command-line input shapes.",
   "license": "MIT",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/dbtlr/loomcli.git"
+  },
+  "files": [
+    "dist",
+    "LICENSE"
+  ],
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "devDependencies": {
+    "ajv": "^8.20.0",
+    "ajv-formats": "^3.0.1"
+  },
+  "peerDependencies": {
+    "@loomcli/core": "0.6.0"
+  },
+  "engines": {
+    "bun": ">=1.4.0",
+    "node": ">=22.23.2"
   }
 }