typesea 0.1.0 → 0.3.0

package/dist/plan/schema-predicate.js

@@ -1,12 +1,16 @@
 /**
  * @file schema-predicate.ts
  * @brief Schema-specialized predicate kernels for validation plans.
+ * @details Plan helpers keep schema-specialized execution aligned with optimized IR while
+ * preserving interpreter parity.
  */
-import { NumberCheckTag, ObjectModeTag, PresenceTag, SchemaTag, StringCheckTag } from "../kind/index.js";
-import { UUID_PATTERN, resolveLazySchema } from "../schema/index.js";
-import { findDiscriminatedUnionCase, hasObjectKey, isDataPropertyDescriptor, isPlainRecord, readOwnDataProperty } from "../evaluate/shared.js";
+import { ArrayCheckTag, DateCheckTag, NumberCheckTag, ObjectModeTag, PresenceTag, SchemaTag, StringCheckTag } from "../kind/index.js";
+import { EMAIL_PATTERN, IPV4_PATTERN, IPV6_PATTERN, ISO_DATETIME_PATTERN, ISO_DATE_PATTERN, ULID_PATTERN, URL_PATTERN, UUID_PATTERN, resolveLazySchema, schemaCanAcceptUndefined } from "../schema/index.js";
+import { findDiscriminatedUnionCase, hasObjectKey, isArrayIndexKey, isDataPropertyDescriptor, isValidDateObject, isPlainRecord, ordinaryHasInstance, readDateTime, readOwnDataProperty } from "../evaluate/shared.js";
 /**
  * @brief execute schema kernel.
+ * @details Plan helpers keep schema-specialized execution aligned with optimized IR while
+ * preserving interpreter parity.
  */
 export function executeSchemaKernel(schema, value, state, runChild) {
     switch (schema.tag) {
@@ -18,6 +22,8 @@ export function executeSchemaKernel(schema, value, state, runChild) {
             return isStringSchema(schema, value);
         case SchemaTag.Number:
             return isNumberSchema(schema, value);
+        case SchemaTag.Date:
+            return isDateSchema(schema, value);
         case SchemaTag.BigInt:
             return typeof value === "bigint";
         case SchemaTag.Symbol:
@@ -27,11 +33,19 @@ export function executeSchemaKernel(schema, value, state, runChild) {
         case SchemaTag.Literal:
             return Object.is(value, schema.value);
         case SchemaTag.Array:
-            return isArraySchema(schema.item, value, state, runChild);
+            return isArraySchema(schema, value, state, runChild);
         case SchemaTag.Tuple:
-            return isTupleSchema(schema.items, value, state, runChild);
+            return isTupleSchema(schema, value, state, runChild);
         case SchemaTag.Record:
             return isRecordSchema(schema.value, value, state, runChild);
+        case SchemaTag.Map:
+            return isMapSchema(schema, value, state, runChild);
+        case SchemaTag.Set:
+            return isSetSchema(schema, value, state, runChild);
+        case SchemaTag.InstanceOf:
+            return ordinaryHasInstance(value, schema.constructor);
+        case SchemaTag.Property:
+            return isPropertySchema(schema, value, state, runChild);
         case SchemaTag.Object:
             return isObjectSchema(schema, value, state, runChild);
         case SchemaTag.Union:
@@ -56,7 +70,12 @@ export function executeSchemaKernel(schema, value, state, runChild) {
     }
 }
 /**
- * @brief is string schema.
+ * @brief Execute a string schema against one runtime value.
+ * @param schema String schema with normalized checks.
+ * @param value Candidate runtime value.
+ * @returns True when the value is a string and every string check passes.
+ * @details Regex state is reset around each test so global or sticky patterns do
+ * not leak `lastIndex` across validation calls.
  */
 function isStringSchema(schema, value) {
     if (typeof value !== "string") {
@@ -93,12 +112,66 @@ function isStringSchema(schema, value) {
                 }
                 UUID_PATTERN.lastIndex = 0;
                 break;
+            case StringCheckTag.Email:
+                EMAIL_PATTERN.lastIndex = 0;
+                if (!EMAIL_PATTERN.test(value)) {
+                    return false;
+                }
+                EMAIL_PATTERN.lastIndex = 0;
+                break;
+            case StringCheckTag.Url:
+                URL_PATTERN.lastIndex = 0;
+                if (!URL_PATTERN.test(value)) {
+                    return false;
+                }
+                URL_PATTERN.lastIndex = 0;
+                break;
+            case StringCheckTag.IsoDate:
+                ISO_DATE_PATTERN.lastIndex = 0;
+                if (!ISO_DATE_PATTERN.test(value)) {
+                    return false;
+                }
+                ISO_DATE_PATTERN.lastIndex = 0;
+                break;
+            case StringCheckTag.IsoDateTime:
+                ISO_DATETIME_PATTERN.lastIndex = 0;
+                if (!ISO_DATETIME_PATTERN.test(value)) {
+                    return false;
+                }
+                ISO_DATETIME_PATTERN.lastIndex = 0;
+                break;
+            case StringCheckTag.Ulid:
+                ULID_PATTERN.lastIndex = 0;
+                if (!ULID_PATTERN.test(value)) {
+                    return false;
+                }
+                ULID_PATTERN.lastIndex = 0;
+                break;
+            case StringCheckTag.Ipv4:
+                IPV4_PATTERN.lastIndex = 0;
+                if (!IPV4_PATTERN.test(value)) {
+                    return false;
+                }
+                IPV4_PATTERN.lastIndex = 0;
+                break;
+            case StringCheckTag.Ipv6:
+                IPV6_PATTERN.lastIndex = 0;
+                if (!IPV6_PATTERN.test(value)) {
+                    return false;
+                }
+                IPV6_PATTERN.lastIndex = 0;
+                break;
         }
     }
     return true;
 }
 /**
- * @brief is number schema.
+ * @brief Execute a number schema against one runtime value.
+ * @details Plan helpers keep schema-specialized execution aligned with optimized IR while
+ * preserving interpreter parity.
+ * @param schema Number schema with normalized checks.
+ * @param value Candidate runtime value.
+ * @returns True when the value is finite and satisfies every numeric check.
  */
 function isNumberSchema(schema, value) {
     if (typeof value !== "number" || !Number.isFinite(value)) {
@@ -126,17 +199,82 @@ function isNumberSchema(schema, value) {
                     return false;
                 }
                 break;
+            case NumberCheckTag.Gt:
+                if (value <= check.value) {
+                    return false;
+                }
+                break;
+            case NumberCheckTag.Lt:
+                if (value >= check.value) {
+                    return false;
+                }
+                break;
+            case NumberCheckTag.MultipleOf:
+                if (value % check.value !== 0) {
+                    return false;
+                }
+                break;
+        }
+    }
+    return true;
+}
+/**
+ * @brief Execute a Date schema against one runtime value.
+ * @param schema Date schema with normalized epoch-millisecond checks.
+ * @param value Candidate runtime value.
+ * @returns True when the value is a valid Date satisfying every bound.
+ */
+function isDateSchema(schema, value) {
+    if (!isValidDateObject(value)) {
+        return false;
+    }
+    const time = readDateTime(value);
+    const checks = schema.checks;
+    for (let index = 0; index < checks.length; index += 1) {
+        const check = checks[index];
+        if (check === undefined) {
+            return false;
+        }
+        switch (check.tag) {
+            case DateCheckTag.Min:
+                if (time < check.value) {
+                    return false;
+                }
+                break;
+            case DateCheckTag.Max:
+                if (time > check.value) {
+                    return false;
+                }
+                break;
         }
     }
     return true;
 }
 /**
- * @brief is array schema.
+ * @brief Execute array validation with sparse-slot semantics.
+ * @details Plan helpers keep schema-specialized execution aligned with optimized IR while
+ * preserving interpreter parity.
+ * @param item Schema applied to each logical array slot.
+ * @param value Candidate value supplied by the caller.
+ * @param state Shared recursion and cycle state.
+ * @param runChild Dispatcher for nested schema predicates.
+ * @returns True when the value satisfies the array schema.
  */
-function isArraySchema(item, value, state, runChild) {
+function isArraySchema(schema, value, state, runChild) {
     if (!Array.isArray(value)) {
         return false;
     }
+    if (!arrayLengthChecksPass(schema, value.length)) {
+        return false;
+    }
+    const item = schema.item;
+    if (schemaCanAcceptUndefined(item)) {
+        /*
+         * Undefined-valid item schemas make holes valid. Use the present-index
+         * walker so sparse arrays do not pay for absent slots.
+         */
+        return isPresentArraySchema(item, value, state, runChild);
+    }
     for (let index = 0; index < value.length; index += 1) {
         const property = readArrayIndexDataProperty(value, index);
         if (property === null ||
@@ -147,10 +285,81 @@ function isArraySchema(item, value, state, runChild) {
     return true;
 }
 /**
- * @brief is tuple schema.
+ * @brief Test array length checks after Array.isArray succeeds.
+ * @param schema Array schema with normalized checks.
+ * @param length Candidate array length.
+ * @returns True when every configured length bound accepts the length.
+ */
+function arrayLengthChecksPass(schema, length) {
+    const checks = schema.checks;
+    for (let index = 0; index < checks.length; index += 1) {
+        const check = checks[index];
+        if (check === undefined) {
+            return false;
+        }
+        switch (check.tag) {
+            case ArrayCheckTag.Min:
+                if (length < check.value) {
+                    return false;
+                }
+                break;
+            case ArrayCheckTag.Max:
+                if (length > check.value) {
+                    return false;
+                }
+                break;
+        }
+    }
+    return true;
+}
+/**
+ * @brief Validate only present indexes for undefined-accepting item schemas.
+ * @details Skips holes only when `undefined` is already accepted by the item schema.
+ * @param item Schema applied to each present own index.
+ * @param value Array already proven by the caller.
+ * @param state Shared recursion and cycle state.
+ * @param runChild Dispatcher for nested schema predicates.
+ * @returns True when every present own index satisfies the item schema.
+ */
+function isPresentArraySchema(item, value, state, runChild) {
+    const keys = Object.getOwnPropertyNames(value);
+    for (let keyIndex = 0; keyIndex < keys.length; keyIndex += 1) {
+        const key = keys[keyIndex];
+        if (key === undefined || !isArrayIndexKey(key, value.length)) {
+            continue;
+        }
+        /*
+         * Accessor-backed present indexes are rejected here because reading them
+         * would run user code and break the safe validation boundary.
+         */
+        const property = readArrayKeyDataProperty(value, key);
+        if (property === null ||
+            (property !== undefined && !runChild(item, property.value, state))) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * @brief Execute fixed-arity tuple validation.
+ * @details Plan helpers keep schema-specialized execution aligned with optimized IR while
+ * preserving interpreter parity.
+ * @param items Schema for each tuple index.
+ * @param value Candidate runtime value.
+ * @param state Shared recursion and cycle state.
+ * @param runChild Dispatcher for nested schema predicates.
+ * @returns True when length and every indexed item match exactly.
  */
-function isTupleSchema(items, value, state, runChild) {
-    if (!Array.isArray(value) || value.length !== items.length) {
+function isTupleSchema(schema, value, state, runChild) {
+    if (!Array.isArray(value)) {
+        return false;
+    }
+    const items = schema.items;
+    const rest = schema.rest;
+    if (rest === undefined && value.length !== items.length) {
+        return false;
+    }
+    if (rest !== undefined && value.length < items.length) {
         return false;
     }
     for (let index = 0; index < items.length; index += 1) {
@@ -162,13 +371,38 @@ function isTupleSchema(items, value, state, runChild) {
             return false;
         }
     }
+    if (rest !== undefined) {
+        for (let index = items.length; index < value.length; index += 1) {
+            const property = readArrayIndexDataProperty(value, index);
+            if (property === null ||
+                !runChild(rest, property === undefined ? undefined : property.value, state)) {
+                return false;
+            }
+        }
+    }
     return true;
 }
 /**
- * @brief read array index data property.
+ * @brief Read one tuple or dense-array index through a descriptor.
+ * @details Plan helpers keep schema-specialized execution aligned with optimized IR while
+ * preserving interpreter parity.
+ * @param value Array being inspected.
+ * @param index Numeric index.
+ * @returns Data descriptor, undefined for a hole, or null for an accessor slot.
  */
 function readArrayIndexDataProperty(value, index) {
-    const descriptor = Object.getOwnPropertyDescriptor(value, String(index));
+    return readArrayKeyDataProperty(value, String(index));
+}
+/**
+ * @brief Read one canonical array index key without executing accessors.
+ * @details Plan helpers keep schema-specialized execution aligned with optimized IR while
+ * preserving interpreter parity.
+ * @param value Array being inspected.
+ * @param key Canonical array index key.
+ * @returns Data descriptor, undefined for a hole, or null for an accessor slot.
+ */
+function readArrayKeyDataProperty(value, key) {
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
     if (descriptor === undefined) {
         return undefined;
     }
@@ -178,7 +412,8 @@ function readArrayIndexDataProperty(value, index) {
     return descriptor;
 }
 /**
- * @brief is record schema.
+ * @brief Check record schema.
+ * @details This helper keeps a local invariant explicit at the module boundary.
  */
 function isRecordSchema(item, value, state, runChild) {
     if (!isPlainRecord(value)) {
@@ -198,7 +433,83 @@ function isRecordSchema(item, value, state, runChild) {
     return true;
 }
 /**
- * @brief is object schema.
+ * @brief Check Map schema.
+ * @param schema Map schema with key and value validators.
+ * @param value Candidate runtime value.
+ * @param state Shared recursion and cycle state.
+ * @param runChild Dispatcher for nested predicates.
+ * @returns True when every entry key and value satisfies its schema.
+ */
+function isMapSchema(schema, value, state, runChild) {
+    if (!(value instanceof Map)) {
+        return false;
+    }
+    const iterator = Map.prototype.entries.call(value);
+    for (;;) {
+        const step = iterator.next();
+        if (step.done === true) {
+            return true;
+        }
+        const pair = step.value;
+        if (!runChild(schema.key, pair[0], state) ||
+            !runChild(schema.value, pair[1], state)) {
+            return false;
+        }
+    }
+}
+/**
+ * @brief Check Set schema.
+ * @param schema Set schema with item validator.
+ * @param value Candidate runtime value.
+ * @param state Shared recursion and cycle state.
+ * @param runChild Dispatcher for nested predicates.
+ * @returns True when every Set item satisfies its schema.
+ */
+function isSetSchema(schema, value, state, runChild) {
+    if (!(value instanceof Set)) {
+        return false;
+    }
+    const iterator = Set.prototype.values.call(value);
+    for (;;) {
+        const step = iterator.next();
+        if (step.done === true) {
+            return true;
+        }
+        if (!runChild(schema.item, step.value, state)) {
+            return false;
+        }
+    }
+}
+/**
+ * @brief Check property schema.
+ * @param schema Property schema with base and own data property validators.
+ * @param value Candidate runtime value.
+ * @param state Shared recursion and cycle state.
+ * @param runChild Dispatcher for nested predicates.
+ * @returns True when base and property value both pass.
+ */
+function isPropertySchema(schema, value, state, runChild) {
+    if (!runChild(schema.base, value, state)) {
+        return false;
+    }
+    if (((typeof value !== "object" && typeof value !== "function") || value === null)) {
+        return false;
+    }
+    const descriptor = Object.getOwnPropertyDescriptor(value, schema.key);
+    return descriptor !== undefined &&
+        isDataPropertyDescriptor(descriptor) &&
+        runChild(schema.value, descriptor.value, state);
+}
+/**
+ * @brief Execute object schema validation.
+ * @param schema Object schema with ordered entries and strict-mode lookup.
+ * @param value Candidate runtime value.
+ * @param state Shared recursion and cycle state.
+ * @param runChild Dispatcher for nested property schemas.
+ * @returns True when required/optional fields and strict-key rules pass.
+ * @details Required properties are read through descriptors. In strict mode, the
+ * all-required path can compare own key counts; optional shapes must inspect
+ * each key so extra symbol or undeclared string keys fail closed.
  */
 function isObjectSchema(schema, value, state, runChild) {
     if (!isPlainRecord(value)) {
@@ -228,6 +539,9 @@ function isObjectSchema(schema, value, state, runChild) {
         }
     }
     if (schema.mode === ObjectModeTag.Strict) {
+        if (schema.catchall !== undefined) {
+            return validateObjectCatchall(schema, record, state, runChild);
+        }
         if (allRequired) {
             return Object.getOwnPropertyNames(record).length === entries.length &&
                 Object.getOwnPropertySymbols(record).length === 0;
@@ -240,10 +554,50 @@ function isObjectSchema(schema, value, state, runChild) {
             }
         }
     }
+    if (schema.catchall !== undefined) {
+        return validateObjectCatchall(schema, record, state, runChild);
+    }
+    return true;
+}
+/**
+ * @brief Validate undeclared own object keys through a catchall schema.
+ * @param schema Object schema carrying known-key metadata and catchall schema.
+ * @param record Runtime object already proven to be a plain record.
+ * @param state Shared recursion and cycle state.
+ * @param runChild Dispatcher for the catchall schema.
+ * @returns True when every extra own data property satisfies the catchall.
+ */
+function validateObjectCatchall(schema, record, state, runChild) {
+    const catchall = schema.catchall;
+    if (catchall === undefined) {
+        return true;
+    }
+    const keys = Reflect.ownKeys(record);
+    for (let index = 0; index < keys.length; index += 1) {
+        const key = keys[index];
+        if (key === undefined ||
+            (typeof key === "string" && hasObjectKey(schema.keyLookup, key))) {
+            continue;
+        }
+        const descriptor = Object.getOwnPropertyDescriptor(record, key);
+        if (descriptor === undefined || !isDataPropertyDescriptor(descriptor)) {
+            return false;
+        }
+        if (!runChild(catchall, descriptor.value, state)) {
+            return false;
+        }
+    }
     return true;
 }
 /**
- * @brief is union schema.
+ * @brief Execute a general union by probing options in order.
+ * @details Plan helpers keep schema-specialized execution aligned with optimized IR while
+ * preserving interpreter parity.
+ * @param options Union option schemas.
+ * @param value Candidate runtime value.
+ * @param state Shared recursion and cycle state.
+ * @param runChild Dispatcher for nested option schemas.
+ * @returns True when at least one option accepts the value.
  */
 function isUnionSchema(options, value, state, runChild) {
     for (let index = 0; index < options.length; index += 1) {
@@ -255,7 +609,15 @@ function isUnionSchema(options, value, state, runChild) {
     return false;
 }
 /**
- * @brief is discriminated union schema.
+ * @brief Execute a discriminated union through its tag field.
+ * @details Plan helpers keep schema-specialized execution aligned with optimized IR while
+ * preserving interpreter parity.
+ * @param key Discriminant property name.
+ * @param cases Closed case table.
+ * @param value Candidate runtime value.
+ * @param state Shared recursion and cycle state.
+ * @param runChild Dispatcher for selected case schema.
+ * @returns True when the discriminant is a string and the selected case passes.
  */
 function isDiscriminatedUnionSchema(key, cases, value, state, runChild) {
     if (!isPlainRecord(value)) {
@@ -270,7 +632,8 @@ function isDiscriminatedUnionSchema(key, cases, value, state, runChild) {
     return selected !== undefined && runChild(selected, value, state);
 }
 /**
- * @brief is strict true.
+ * @brief Check strict true.
+ * @details This helper keeps a local invariant explicit at the module boundary.
  */
 function isStrictTrue(value) {
     return value === true;

package/dist/plan/types.d.ts

@@ -1,6 +1,8 @@
 /**
  * @file types.ts
  * @brief Optimized validation plan contracts.
+ * @details Plan helpers keep schema-specialized execution aligned with optimized IR while
+ * preserving interpreter parity.
  */
 import type { Graph } from "../ir/index.js";
 import type { Schema } from "../schema/index.js";

package/dist/plan/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/plan/types.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAC5C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAEjD;;;;;GAKG;AACH,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC;IACtB,QAAQ,CAAC,eAAe,EAAE,OAAO,CAAC;CACnC"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/plan/types.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAC5C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAEjD;;;;;GAKG;AACH,MAAM,WAAW,cAAc;IAC3B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC;IACtB,QAAQ,CAAC,eAAe,EAAE,OAAO,CAAC;CACrC"}

package/dist/plan/types.js

@@ -1,5 +1,7 @@
 /**
  * @file types.ts
  * @brief Optimized validation plan contracts.
+ * @details Plan helpers keep schema-specialized execution aligned with optimized IR while
+ * preserving interpreter parity.
  */
 export {};

package/dist/result/index.d.ts

@@ -1,27 +1,41 @@
 /**
- * @brief result.
+ * @brief Explicit success-or-failure value used instead of implicit exceptions.
+ * @details Public validators return Result so failure is visible in the type
+ * system and callers must handle diagnostics deliberately.
  */
 export type Result<TValue, TError> = Ok<TValue> | Err<TError>;
 /**
- * @brief ok.
+ * @brief Successful Result variant.
+ * @details The payload is named `value` so consumers can destructure success
+ * without colliding with the failure-side `error` field.
  */
 export interface Ok<TValue> {
     readonly ok: true;
     readonly value: TValue;
 }
 /**
- * @brief err.
+ * @brief Failed Result variant.
+ * @details Errors remain typed payloads rather than thrown control flow, which
+ * keeps validation and decoding APIs predictable under composition.
  */
 export interface Err<TError> {
     readonly ok: false;
     readonly error: TError;
 }
 /**
- * @brief ok.
+ * @brief Construct a frozen successful Result.
+ * @details Result helpers keep success and failure explicit in value space instead of
+ * relying on implicit control flow.
+ * @param value Value produced by a successful operation.
+ * @returns Immutable success variant.
  */
 export declare function ok<TValue>(value: TValue): Result<TValue, never>;
 /**
- * @brief err.
+ * @brief Construct a frozen failed Result.
+ * @details Result helpers keep success and failure explicit in value space instead of
+ * relying on implicit control flow.
+ * @param error Typed failure payload.
+ * @returns Immutable failure variant.
  */
 export declare function err<TError>(error: TError): Result<never, TError>;
 //# sourceMappingURL=index.d.ts.map

package/dist/result/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/result/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,MAAM,MAAM,CAAC,MAAM,EAAE,MAAM,IAC7B,EAAE,CAAC,MAAM,CAAC,GACV,GAAG,CAAC,MAAM,CAAC,CAAC;AAEhB;;GAEG;AACH,MAAM,WAAW,EAAE,CAAC,MAAM;IACxB,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC;IAClB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AAED;;GAEG;AACH,MAAM,WAAW,GAAG,CAAC,MAAM;IACzB,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC;IACnB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AAED;;GAEG;AACH,wBAAgB,EAAE,CAAC,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAM/D;AAED;;GAEG;AACH,wBAAgB,GAAG,CAAC,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC,KAAK,EAAE,MAAM,CAAC,CAMhE"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/result/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,MAAM,MAAM,CAAC,MAAM,EAAE,MAAM,IAC3B,EAAE,CAAC,MAAM,CAAC,GACV,GAAG,CAAC,MAAM,CAAC,CAAC;AAElB;;;;GAIG;AACH,MAAM,WAAW,EAAE,CAAC,MAAM;IACtB,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC;IAClB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CAC1B;AAED;;;;GAIG;AACH,MAAM,WAAW,GAAG,CAAC,MAAM;IACvB,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC;IACnB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CAC1B;AAED;;;;;;GAMG;AACH,wBAAgB,EAAE,CAAC,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAM/D;AAED;;;;;;GAMG;AACH,wBAAgB,GAAG,CAAC,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC,KAAK,EAAE,MAAM,CAAC,CAMhE"}

package/dist/result/index.js

@@ -1,5 +1,9 @@
 /**
- * @brief ok.
+ * @brief Construct a frozen successful Result.
+ * @details Result helpers keep success and failure explicit in value space instead of
+ * relying on implicit control flow.
+ * @param value Value produced by a successful operation.
+ * @returns Immutable success variant.
  */
 export function ok(value) {
     const result = {
@@ -9,7 +13,11 @@ export function ok(value) {
     return Object.freeze(result);
 }
 /**
- * @brief err.
+ * @brief Construct a frozen failed Result.
+ * @details Result helpers keep success and failure explicit in value space instead of
+ * relying on implicit control flow.
+ * @param error Typed failure payload.
+ * @returns Immutable failure variant.
  */
 export function err(error) {
     const result = {