@loomcli/validators 0.0.0 → 0.6.0

package/dist/integer.js

@@ -0,0 +1,31 @@
+import { boundsIssue, boundsSchema, readBounds, withinBounds, withoutNegativeZero, } from './bounds.js';
+import { integerCodes } from './codes.js';
+import { createValidator } from './create.js';
+import { reject } from './issues.js';
+const digits = /^-?[0-9]+$/u;
+/** The safe integer a token spells in decimal digits, `-0` as `0`, or undefined when none. */
+function readInteger(raw) {
+    if (!digits.test(raw)) {
+        return undefined;
+    }
+    const value = Number(raw);
+    return Number.isSafeInteger(value) ? withoutNegativeZero(value) : undefined;
+}
+/** A decimal whole number that is a safe integer within `min` and `max`, both inclusive. */
+function integer(options) {
+    const bounds = readBounds(options, {
+        accepts: Number.isSafeInteger,
+        correction: 'Supply a whole number from -9007199254740991 through 9007199254740991.',
+        factory: 'integer',
+        requirement: 'a safe integer',
+    });
+    const issue = boundsIssue(integerCodes, bounds);
+    return createValidator({
+        inputSchema: boundsSchema('integer', bounds),
+        parse: (raw) => {
+            const value = readInteger(raw);
+            return value !== undefined && withinBounds(value, bounds) ? { value } : reject(issue);
+        },
+    });
+}
+export { integer, readInteger };

package/dist/issue-code.d.ts

@@ -0,0 +1,24 @@
+import type { StandardSchemaV1 } from '@loomcli/core';
+/**
+ * One issue code a validator package declares: the code string, the schema its parameters pass,
+ * a builder for the issue a `parse` function returns, and a typed read of that issue.
+ */
+interface IssueCode<Params> {
+    readonly code: string;
+    readonly schema: StandardSchemaV1<Params>;
+    issue(this: void, params: Params): StandardSchemaV1.Issue;
+    read(this: void, issue: StandardSchemaV1.Issue): Params | undefined;
+}
+/** What `issueCode` declares beside the code: the parameter schema and the one sentence. */
+interface IssueCodeConfig<Params> {
+    schema: StandardSchemaV1<Params>;
+    message: (params: Params) => string;
+}
+/**
+ * Declares one issue code with its parameter schema and its one sentence, and returns a frozen
+ * descriptor. `issue` builds the rejection a `parse` function returns, and `read` recovers the
+ * typed parameters from an issue carrying the code.
+ */
+declare function issueCode<Params>(code: string, config: IssueCodeConfig<Params>): IssueCode<Params>;
+export { issueCode };
+export type { IssueCode, IssueCodeConfig };

package/dist/issue-code.js

@@ -0,0 +1,183 @@
+import { isRuleIdentity } from '@loomcli/core';
+import { isPlainObject } from './data.js';
+import { fault, quote } from './faults.js';
+import { issueCodeConfig, issueCodeName, issueCodeSchema, issueParameters } from './rules.js';
+/** The Standard Schema version this package reads. */
+const standardVersion = 1;
+/** Whether a value is an object or a function, which alone can carry fields. */
+function isObjectLike(value) {
+    return value !== null && (typeof value === 'object' || typeof value === 'function');
+}
+/**
+ * Whether a value answers the Standard Schema v1 contract, as core checks a validator. A value
+ * whose fields throw when read, through a getter or a proxy trap, is not a Standard Schema.
+ */
+function isStandardSchema(value) {
+    try {
+        if (!isObjectLike(value)) {
+            return false;
+        }
+        const standard = '~standard' in value ? value['~standard'] : undefined;
+        return (standard !== null &&
+            typeof standard === 'object' &&
+            'version' in standard &&
+            standard.version === standardVersion &&
+            'vendor' in standard &&
+            typeof standard.vendor === 'string' &&
+            'validate' in standard &&
+            typeof standard.validate === 'function');
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * The verdict a schema's result states, or `undefined` for a value that is not a Standard Schema
+ * result: a success must hold its own `value` and no issues, and a failure an issues array. Both
+ * `issue` and `read` read a result here, so neither keeps parameters the schema never output. A
+ * getter or a proxy trap that throws while the result is read propagates to the caller.
+ */
+function verdictOf(result) {
+    if (!isObjectLike(result)) {
+        return undefined;
+    }
+    if (result.issues === undefined) {
+        return Object.hasOwn(result, 'value') ? { kind: 'accepted', params: result.value } : undefined;
+    }
+    const issues = result.issues;
+    return Array.isArray(issues) ? { kind: 'rejected' } : undefined;
+}
+/** The verdict a result states, where a result that throws while it is read states none. */
+function verdictOrNothing(result) {
+    try {
+        return verdictOf(result);
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Whether a schema's answer is a promise or another thenable, which a synchronous read cannot
+ * wait for. A value whose `then` cannot be read is not a thenable, so the test never throws.
+ */
+function isThenable(value) {
+    try {
+        return isObjectLike(value) && 'then' in value && typeof value.then === 'function';
+    }
+    catch {
+        return false;
+    }
+}
+/** The `issueCode()` call a fault marks one part of: the code, the config, or one of its keys. */
+function declarationAt(code, config, mark) {
+    return { arguments: [code, config], factory: 'issueCode', mark };
+}
+/** The mark for one key of a config object, or the config itself when the key is absent. */
+function keyMark(config, key) {
+    return key in config ? `1.${key}` : '1';
+}
+/** Faults on a declaration that bypassed the types: a code outside the grammar, or a bad config. */
+function checkDeclaration(code, config) {
+    if (!isRuleIdentity(code)) {
+        throw fault(issueCodeName, declarationAt(code, config, '0'), {
+            correction: 'Supply a code such as "@acme/validators/port-range", with each subpath segment and the rule of lowercase letters and digits in words joined by single hyphens.',
+            sentence: `issueCode() code ${quote(code)} is not a package name, any subpath segments, and a rule name joined by slashes.`,
+        });
+    }
+    if (!isPlainObject(config)) {
+        throw fault(issueCodeConfig, declarationAt(code, config, '1'), {
+            correction: 'Supply an object with a schema and a message function.',
+            sentence: 'issueCode() config is not a plain object.',
+        });
+    }
+    if (!isStandardSchema(config.schema)) {
+        throw fault(issueCodeConfig, declarationAt(code, config, keyMark(config, 'schema')), {
+            correction: 'Supply a Standard Schema value that validates the parameters.',
+            sentence: 'issueCode() schema is not a Standard Schema.',
+        });
+    }
+    if (typeof config.message !== 'function') {
+        throw fault(issueCodeConfig, declarationAt(code, config, keyMark(config, 'message')), {
+            correction: 'Supply a function that builds the sentence from the parameters.',
+            sentence: 'issueCode() message is not a function.',
+        });
+    }
+}
+/**
+ * Declares one issue code with its parameter schema and its one sentence, and returns a frozen
+ * descriptor. `issue` builds the rejection a `parse` function returns, and `read` recovers the
+ * typed parameters from an issue carrying the code.
+ */
+function issueCode(code, config) {
+    checkDeclaration(code, config);
+    const { message, schema } = config;
+    // A schema fault is the declaration's, so it marks the schema the code was declared with.
+    const schemaAt = declarationAt(code, config, '1.schema');
+    /** The schema's synchronous result; a promise faults, since neither caller can wait for it. */
+    function settled(answer) {
+        if (isThenable(answer)) {
+            // The unawaited answer may still reject, and an unobserved rejection would end the process.
+            void Promise.resolve(answer).catch(() => undefined);
+            throw fault(issueCodeSchema, schemaAt, {
+                correction: 'Supply a schema that validates synchronously.',
+                sentence: `Issue code ${JSON.stringify(code)} has a schema that answers with a promise.`,
+            });
+        }
+        return answer;
+    }
+    /** The schema's answer to the parameters `issue` was given; a throw is the declaration's fault. */
+    function declaredAnswer(params) {
+        try {
+            return schema['~standard'].validate(params);
+        }
+        catch {
+            throw fault(issueCodeSchema, schemaAt, {
+                correction: 'Supply a schema that returns its issues instead of throwing.',
+                sentence: `Issue code ${JSON.stringify(code)} has a schema that throws in issue().`,
+            });
+        }
+    }
+    /**
+     * The verdict `issue` builds from. Anything but a well-formed synchronous result is the
+     * declaration's fault, so a result that throws while it is read is not a result either.
+     */
+    function declaredVerdict(params) {
+        const verdict = verdictOrNothing(settled(declaredAnswer(params)));
+        if (verdict === undefined) {
+            throw fault(issueCodeSchema, schemaAt, {
+                correction: 'Supply a schema that returns its value or its issues.',
+                sentence: `Issue code ${JSON.stringify(code)} has a schema that answers with a value that is not a Standard Schema result.`,
+            });
+        }
+        return verdict;
+    }
+    return Object.freeze({
+        code,
+        issue: (params) => {
+            const verdict = declaredVerdict(params);
+            if (verdict.kind === 'rejected') {
+                throw fault(issueParameters, { arguments: [params], factory: 'issue', mark: '0' }, {
+                    correction: 'Supply parameters its schema accepts.',
+                    sentence: `Issue code ${JSON.stringify(code)} rejects the parameters passed to issue().`,
+                });
+            }
+            return Object.freeze({ code, message: message(verdict.params), params: verdict.params });
+        },
+        // Core hands a failure view a plain-object copy of each issue a validator returned.
+        // Reading the copy's own fields runs no getter, and its parameters reach the schema as they are.
+        read: (issue) => {
+            const candidate = issue;
+            if (!isObjectLike(candidate) || !('code' in candidate) || candidate.code !== code) {
+                return undefined;
+            }
+            const params = 'params' in candidate ? candidate.params : undefined;
+            if (!isObjectLike(params)) {
+                return undefined;
+            }
+            const verdict = verdictOf(settled(schema['~standard'].validate(params)));
+            return verdict?.kind === 'accepted' ? verdict.params : undefined;
+        },
+        schema,
+    });
+}
+export { issueCode };

package/dist/issues.d.ts

@@ -0,0 +1,6 @@
+import type { StandardSchemaV1 } from '@loomcli/core';
+/** A rejection: one issue with no path, carrying the configuration's code and one sentence. */
+declare function reject(issue: StandardSchemaV1.Issue): StandardSchemaV1.FailureResult;
+/** Joins items as a sentence lists them: `a`, `a or b`, or `a, b, or c`. */
+declare function listing(items: readonly string[]): string;
+export { listing, reject };

package/dist/issues.js

@@ -0,0 +1,17 @@
+/** The longest list that joins with `or` alone. */
+const pair = 2;
+const first = 0;
+/** The index of the last item, counted from the end. */
+const last = -1;
+/** A rejection: one issue with no path, carrying the configuration's code and one sentence. */
+function reject(issue) {
+    return { issues: [issue] };
+}
+/** Joins items as a sentence lists them: `a`, `a or b`, or `a, b, or c`. */
+function listing(items) {
+    if (items.length <= pair) {
+        return items.join(' or ');
+    }
+    return `${items.slice(first, last).join(', ')}, or ${items.at(last) ?? ''}`;
+}
+export { listing, reject };

package/dist/number.d.ts

@@ -0,0 +1,9 @@
+import type { Validator } from './create.js';
+interface NumberOptions {
+    min?: number;
+    max?: number;
+}
+/** A finite decimal number, with an optional fraction and exponent, within `min` and `max`. */
+declare function number(options?: NumberOptions): Validator<number>;
+export { number };
+export type { NumberOptions };

package/dist/number.js

@@ -0,0 +1,26 @@
+import { boundsIssue, boundsSchema, readBounds, withinBounds, withoutNegativeZero, } from './bounds.js';
+import { numberCodes } from './codes.js';
+import { createValidator } from './create.js';
+import { reject } from './issues.js';
+const decimal = /^-?[0-9]+(?:\.[0-9]+)?(?:[eE][+-]?[0-9]+)?$/u;
+/** A finite decimal number, with an optional fraction and exponent, within `min` and `max`. */
+function number(options) {
+    const bounds = readBounds(options, {
+        accepts: Number.isFinite,
+        correction: 'Supply a finite number.',
+        factory: 'number',
+        requirement: 'a finite number',
+    });
+    const issue = boundsIssue(numberCodes, bounds);
+    return createValidator({
+        inputSchema: boundsSchema('number', bounds),
+        parse: (raw) => {
+            if (!decimal.test(raw)) {
+                return reject(issue);
+            }
+            const value = withoutNegativeZero(Number(raw));
+            return Number.isFinite(value) && withinBounds(value, bounds) ? { value } : reject(issue);
+        },
+    });
+}
+export { number };

package/dist/one-of.d.ts

@@ -0,0 +1,4 @@
+import type { Validator } from './create.js';
+/** A token exactly equal to one of the declared values, typed as their union. */
+declare function oneOf<const Values extends readonly [string, ...string[]]>(values: Values): Validator<Values[number]>;
+export { oneOf };

package/dist/one-of.js

@@ -0,0 +1,79 @@
+import { DeclarationError } from '@loomcli/core';
+import { oneOfIssue } from './codes.js';
+import { createValidator } from './create.js';
+import { fault } from './faults.js';
+import { reject } from './issues.js';
+import { oneOfValues } from './rules.js';
+const empty = 0;
+/** A fault of the list `oneOf()` received, marking the list or one of its values. */
+function listFault(values, mark, parts) {
+    return fault(oneOfValues, { arguments: [values], factory: 'oneOf', mark }, parts);
+}
+/** The declared list as unknown items, after faulting on one that is not an array or is empty. */
+function checkList(values) {
+    if (!Array.isArray(values)) {
+        throw listFault(values, '0', {
+            correction: 'Supply an array of strings.',
+            sentence: 'oneOf() values is not an array.',
+        });
+    }
+    const items = values;
+    if (items.length === empty) {
+        throw listFault(values, '0', {
+            correction: 'List at least one value.',
+            sentence: 'oneOf() values is empty.',
+        });
+    }
+    return items;
+}
+/**
+ * Faults on a value that is not a string, is empty, or was listed earlier. `seen` holds the
+ * position of each value listed so far, so a repeat marks both.
+ */
+function checkValue(listed, index, seen) {
+    const item = listed[index];
+    if (typeof item !== 'string') {
+        throw listFault(listed, `0.${String(index)}`, {
+            correction: 'List strings only.',
+            sentence: 'oneOf() lists a value that is not a string.',
+        });
+    }
+    if (item === '') {
+        throw listFault(listed, `0.${String(index)}`, {
+            correction: 'List nonempty values only.',
+            sentence: 'oneOf() lists an empty string.',
+        });
+    }
+    const first = seen.get(item);
+    if (first !== undefined) {
+        const call = { arguments: [listed], call: 'oneOf' };
+        throw new DeclarationError(oneOfValues, {
+            correction: 'List each value once.',
+            findings: [
+                { ...call, mark: `0.${String(first)}`, note: 'the first' },
+                { ...call, mark: `0.${String(index)}`, note: 'the second' },
+            ],
+            sentence: `oneOf() lists ${JSON.stringify(item)} twice.`,
+        });
+    }
+    seen.set(item, index);
+}
+/** A token exactly equal to one of the declared values, typed as their union. */
+function oneOf(values) {
+    checkList(values);
+    // The copy is what the validator keeps, so the checks read the copy and not the caller's list.
+    const listed = [...values];
+    const seen = new Map();
+    for (const index of listed.keys()) {
+        checkValue(listed, index, seen);
+    }
+    const issue = oneOfIssue.issue({ values: listed });
+    return createValidator({
+        inputSchema: { type: 'string', enum: [...listed] },
+        parse: (raw) => {
+            const match = listed.find((value) => value === raw);
+            return match === undefined ? reject(issue) : { value: match };
+        },
+    });
+}
+export { oneOf };

package/dist/params.d.ts

@@ -0,0 +1,54 @@
+import type { StandardSchemaV1 } from '@loomcli/core';
+import type { PathKind } from './probe.js';
+/** A check on one parameter that also tells the compiler its type. */
+type Guard<Value> = (value: unknown) => value is Value;
+/** The parameters of a code whose sentence has no blank. */
+type NoParams = Readonly<Record<string, never>>;
+declare const isCount: Guard<number>;
+declare const isSafeInteger: Guard<number>;
+declare const isFiniteNumber: Guard<number>;
+declare const noParams: StandardSchemaV1<Readonly<Record<string, never>>, Readonly<Record<string, never>>>;
+declare function minParams(accepts: Guard<number>): StandardSchemaV1<{
+    min: number;
+}, {
+    min: number;
+}>;
+declare function maxParams(accepts: Guard<number>): StandardSchemaV1<{
+    max: number;
+}, {
+    max: number;
+}>;
+declare function rangeParams(accepts: Guard<number>): StandardSchemaV1<{
+    max: number;
+    min: number;
+}, {
+    max: number;
+    min: number;
+}>;
+declare const lengthParams: StandardSchemaV1<{
+    length: number;
+}, {
+    length: number;
+}>;
+declare const messageParams: StandardSchemaV1<{
+    message: string;
+}, {
+    message: string;
+}>;
+declare const valuesParams: StandardSchemaV1<{
+    values: readonly string[];
+}, {
+    values: readonly string[];
+}>;
+declare const protocolsParams: StandardSchemaV1<{
+    protocols: readonly string[];
+}, {
+    protocols: readonly string[];
+}>;
+declare const kindParams: StandardSchemaV1<{
+    kind: PathKind;
+}, {
+    kind: PathKind;
+}>;
+export { isCount, isFiniteNumber, isSafeInteger, kindParams, lengthParams, maxParams, messageParams, minParams, noParams, protocolsParams, rangeParams, valuesParams, };
+export type { NoParams };

package/dist/params.js

@@ -0,0 +1,68 @@
+import { vendor } from './create.js';
+import { isPlainObject } from './data.js';
+/**
+ * A Standard Schema for one fixed parameter shape, built without a schema library. It accepts a
+ * plain object with exactly `keys`, which `read` turns into the typed parameters, and outputs a
+ * frozen copy, so an issue's parameters cannot be changed by a reader.
+ */
+function paramsSchema(shape, keys, read) {
+    const refusal = () => ({
+        issues: [{ message: `Expected the parameters ${shape}.` }],
+    });
+    return Object.freeze({
+        '~standard': Object.freeze({
+            validate: (value) => {
+                if (!isPlainObject(value)) {
+                    return refusal();
+                }
+                const exact = Object.keys(value).length === keys.length &&
+                    keys.every((key) => Object.hasOwn(value, key));
+                const params = exact ? read(value) : undefined;
+                if (params === undefined) {
+                    return refusal();
+                }
+                Object.freeze(params);
+                return { value: params };
+            },
+            vendor,
+            version: 1,
+        }),
+    });
+}
+const none = 0;
+const isCount = (value) => typeof value === 'number' && Number.isSafeInteger(value) && value >= none;
+const isSafeInteger = (value) => typeof value === 'number' && Number.isSafeInteger(value);
+const isFiniteNumber = (value) => typeof value === 'number' && Number.isFinite(value);
+const isKind = (value) => value === 'file' || value === 'directory' || value === 'any';
+/** A nonempty list of strings, copied and frozen, or undefined for anything else. */
+function stringList(value) {
+    if (!Array.isArray(value)) {
+        return undefined;
+    }
+    const items = value;
+    return items.length > none && items.every((item) => typeof item === 'string')
+        ? Object.freeze([...items])
+        : undefined;
+}
+const noParams = paramsSchema('{}', [], () => ({}));
+function minParams(accepts) {
+    return paramsSchema('{ min: number }', ['min'], ({ min }) => accepts(min) ? { min } : undefined);
+}
+function maxParams(accepts) {
+    return paramsSchema('{ max: number }', ['max'], ({ max }) => accepts(max) ? { max } : undefined);
+}
+function rangeParams(accepts) {
+    return paramsSchema('{ min: number; max: number }', ['max', 'min'], ({ max, min }) => accepts(max) && accepts(min) ? { max, min } : undefined);
+}
+const lengthParams = paramsSchema('{ length: number }', ['length'], ({ length }) => isCount(length) ? { length } : undefined);
+const messageParams = paramsSchema('{ message: string }', ['message'], ({ message }) => typeof message === 'string' && message !== '' ? { message } : undefined);
+const valuesParams = paramsSchema('{ values: readonly string[] }', ['values'], (record) => {
+    const values = stringList(record.values);
+    return values === undefined ? undefined : { values };
+});
+const protocolsParams = paramsSchema('{ protocols: readonly string[] }', ['protocols'], (record) => {
+    const protocols = stringList(record.protocols);
+    return protocols === undefined ? undefined : { protocols };
+});
+const kindParams = paramsSchema("{ kind: 'file' | 'directory' | 'any' }", ['kind'], ({ kind }) => isKind(kind) ? { kind } : undefined);
+export { isCount, isFiniteNumber, isSafeInteger, kindParams, lengthParams, maxParams, messageParams, minParams, noParams, protocolsParams, rangeParams, valuesParams, };

package/dist/path.d.ts

@@ -0,0 +1,13 @@
+import type { Validator } from './create.js';
+import type { PathKind } from './probe.js';
+interface PathOptions {
+    access?: 'read' | 'write';
+    kind?: PathKind;
+}
+/**
+ * A path resolved against the host's cwd under the host platform's rules, and normalized.
+ * With `access`, the filesystem is probed; the probe is advisory, since the filesystem can change.
+ */
+declare function path(options?: PathOptions): Validator<string>;
+export { path };
+export type { PathOptions };

package/dist/path.js

@@ -0,0 +1,64 @@
+import { posix, win32 } from 'node:path';
+import { pathIssue, pathReadableIssue, pathWritableIssue } from './codes.js';
+import { createValidator } from './create.js';
+import { fault, readOptions } from './faults.js';
+import { reject } from './issues.js';
+import { readable, writable } from './probe.js';
+import { pathCheck } from './rules.js';
+function accessOf(call, value) {
+    if (value === undefined || value === 'read' || value === 'write') {
+        return value;
+    }
+    throw fault(pathCheck, { ...call, mark: '0.access' }, {
+        correction: 'Supply "read" or "write".',
+        sentence: 'path() access is not "read" or "write".',
+    });
+}
+function kindOf(call, value, access) {
+    const at = { ...call, mark: '0.kind' };
+    if (value !== undefined && access === undefined) {
+        throw fault(pathCheck, at, {
+            correction: 'Supply an access or leave out kind.',
+            sentence: 'path() kind has no access to check.',
+        });
+    }
+    if (value === undefined || value === 'file' || value === 'directory' || value === 'any') {
+        return value ?? 'file';
+    }
+    throw fault(pathCheck, at, {
+        correction: 'Supply one of them.',
+        sentence: 'path() kind is not "file", "directory", or "any".',
+    });
+}
+/**
+ * A path resolved against the host's cwd under the host platform's rules, and normalized.
+ * With `access`, the filesystem is probed; the probe is advisory, since the filesystem can change.
+ */
+function path(options) {
+    const declared = readOptions('path', options);
+    const call = { arguments: [options], factory: 'path' };
+    const access = accessOf(call, declared.access);
+    const kind = kindOf(call, declared.kind, access);
+    const issue = access === undefined
+        ? pathIssue.issue({})
+        : (access === 'read' ? pathReadableIssue : pathWritableIssue).issue({ kind });
+    return createValidator({
+        inputSchema: { type: 'string', minLength: 1 },
+        parse: (raw, context) => {
+            if (raw === '' || raw.includes('\0')) {
+                return reject(issue);
+            }
+            const { cwd, platform } = context.host;
+            const rules = platform === 'win32' ? win32 : posix;
+            const resolved = rules.resolve(cwd, raw);
+            if (access === undefined) {
+                return { value: resolved };
+            }
+            const probe = access === 'read'
+                ? readable(resolved, kind)
+                : writable(resolved, kind, rules.dirname(resolved));
+            return probe.then((passes) => (passes ? { value: resolved } : reject(issue)));
+        },
+    });
+}
+export { path };

package/dist/port.d.ts

@@ -0,0 +1,4 @@
+import type { Validator } from './create.js';
+/** A TCP or UDP port the operator names, 1 through 65535; port 0 is left to `integer()`. */
+declare function port(): Validator<number>;
+export { port };

package/dist/port.js

@@ -0,0 +1,18 @@
+import { boundsSchema, withinBounds } from './bounds.js';
+import { portIssue } from './codes.js';
+import { createValidator } from './create.js';
+import { readInteger } from './integer.js';
+import { reject } from './issues.js';
+const range = { max: 65_535, min: 1 };
+/** A TCP or UDP port the operator names, 1 through 65535; port 0 is left to `integer()`. */
+function port() {
+    const issue = portIssue.issue({});
+    return createValidator({
+        inputSchema: boundsSchema('integer', range),
+        parse: (raw) => {
+            const value = readInteger(raw);
+            return value !== undefined && withinBounds(value, range) ? { value } : reject(issue);
+        },
+    });
+}
+export { port };

package/dist/probe.d.ts

@@ -0,0 +1,11 @@
+type PathKind = 'file' | 'directory' | 'any';
+/** Runs one probe, reading a verdict failure as `false` and rethrowing any other failure. */
+declare function holds(probe: () => Promise<boolean>): Promise<boolean>;
+declare function readable(target: string, kind: PathKind): Promise<boolean>;
+/**
+ * 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.
+ */
+declare function writable(target: string, kind: PathKind, parent: string): Promise<boolean>;
+export { holds, readable, writable };
+export type { PathKind };