nalloc 0.2.2 → 0.5.0

package/build/safe.cjs

@@ -12,12 +12,18 @@ _export(exports, {
     get Iter () {
         return _itercjs;
     },
+    get NonEmpty () {
+        return _nonemptycjs;
+    },
     get Option () {
         return _optioncjs;
     },
     get Result () {
         return _resultcjs;
     },
+    get Schema () {
+        return _schemacjs;
+    },
     get err () {
         return _typescjs.err;
     },
@@ -71,6 +77,8 @@ const _typescjs = require("./types.cjs");
 const _resultcjs = /*#__PURE__*/ _interop_require_wildcard(require("./result.cjs"));
 const _optioncjs = /*#__PURE__*/ _interop_require_wildcard(require("./option.cjs"));
 const _itercjs = /*#__PURE__*/ _interop_require_wildcard(require("./iter.cjs"));
+const _nonemptycjs = /*#__PURE__*/ _interop_require_wildcard(require("./nonempty.cjs"));
+const _schemacjs = /*#__PURE__*/ _interop_require_wildcard(require("./schema.cjs"));
 function _getRequireWildcardCache(nodeInterop) {
     if (typeof WeakMap !== "function") return null;
     var cacheBabelInterop = new WeakMap();

package/build/safe.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/safe.ts"],"sourcesContent":["export { some, none, ok, err, isOk, isErr, isSome, isNone, isThenable, isSync } from './types.js';\nexport type {\n  Some,\n  None,\n  Ok,\n  Err,\n  Option as OptionType,\n  OptionValue,\n  IsOption,\n  InferSome,\n  Result as ResultType,\n  ResultValue,\n  ResultErrorType,\n  IsResult,\n  InferErr,\n  MaybePromise,\n} from './types.js';\nexport { safeTry, safeTryAsync, unwrap, gen, genAsync } from './result.js';\nexport * as Option from './option.js';\nexport * as Result from './result.js';\nexport * as Iter from './iter.js';\n\n/**\n * Threads a value through a sequence of unary functions, left to right.\n * @param value - The initial value\n * @param fns - Functions to apply in order\n * @returns The result of applying all functions\n * @example\n * pipe(\n *   Result.tryCatch(() => JSON.parse(input)),\n *   r => Result.flatMap(r, validate),\n *   r => Result.map(r, transform),\n * )\n */\nexport function pipe<A>(a: A): A;\nexport function pipe<A, B>(a: A, ab: (a: A) => B): B;\nexport function pipe<A, B, C>(a: A, ab: (a: A) => B, bc: (b: B) => C): C;\nexport function pipe<A, B, C, D>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D): D;\nexport function pipe<A, B, C, D, E>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E): E;\nexport function pipe<A, B, C, D, E, F>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F): F;\nexport function pipe<A, B, C, D, E, F, G>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G): G;\nexport function pipe<A, B, C, D, E, F, G, H>(\n  a: A,\n  ab: (a: A) => B,\n  bc: (b: B) => C,\n  cd: (c: C) => D,\n  de: (d: D) => E,\n  ef: (e: E) => F,\n  fg: (f: F) => G,\n  gh: (g: G) => H,\n): H;\nexport function pipe<A, B, C, D, E, F, G, H, I>(\n  a: A,\n  ab: (a: A) => B,\n  bc: (b: B) => C,\n  cd: (c: C) => D,\n  de: (d: D) => E,\n  ef: (e: E) => F,\n  fg: (f: F) => G,\n  gh: (g: G) => H,\n  hi: (h: H) => I,\n): I;\nexport function pipe(a: unknown, ...fns: ((v: unknown) => unknown)[]): unknown {\n  let result = a;\n  for (let i = 0; i < fns.length; i++) {\n    result = fns[i](result);\n  }\n  return result;\n}\n"],"names":["Iter","Option","Result","err","gen","genAsync","isErr","isNone","isOk","isSome","isSync","isThenable","none","ok","pipe","safeTry","safeTryAsync","some","unwrap","a","fns","result","i","length"],"mappings":";;;;;;;;;;;QAoBYA;;;QAFAC;;;QACAC;;;QAnBaC;eAAAA,aAAG;;QAiBYC;eAAAA,cAAG;;QAAEC;eAAAA,mBAAQ;;QAjBjBC;eAAAA,eAAK;;QAAUC;eAAAA,gBAAM;;QAA3BC;eAAAA,cAAI;;QAASC;eAAAA,gBAAM;;QAAsBC;eAAAA,gBAAM;;QAAlBC;eAAAA,oBAAU;;QAAtDC;eAAAA,cAAI;;QAAEC;eAAAA,YAAE;;QA8DPC;eAAAA;;QA7CPC;eAAAA,kBAAO;;QAAEC;eAAAA,uBAAY;;QAjBrBC;eAAAA,cAAI;;QAiBmBC;eAAAA,iBAAM;;;0BAjB+C;mEAiBxB;mEACrC;iEAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0Cf,SAASJ,KAAKK,CAAU,EAAE,GAAGC,GAAgC;IAClE,IAAIC,SAASF;IACb,IAAK,IAAIG,IAAI,GAAGA,IAAIF,IAAIG,MAAM,EAAED,IAAK;QACnCD,SAASD,GAAG,CAACE,EAAE,CAACD;IAClB;IACA,OAAOA;AACT"}
+{"version":3,"sources":["../src/safe.ts"],"sourcesContent":["export { some, none, ok, err, isOk, isErr, isSome, isNone, isThenable, isSync } from './types.js';\nexport type {\n  Some,\n  None,\n  Ok,\n  Err,\n  Option as OptionType,\n  OptionValue,\n  IsOption,\n  InferSome,\n  Result as ResultType,\n  ResultValue,\n  ResultErrorType,\n  IsResult,\n  InferErr,\n  MaybePromise,\n} from './types.js';\nexport { safeTry, safeTryAsync, unwrap, gen, genAsync } from './result.js';\nexport type { NonEmptyArray, ReadonlyNonEmptyArray } from './nonempty.js';\nexport * as Option from './option.js';\nexport * as Result from './result.js';\nexport * as Iter from './iter.js';\nexport * as NonEmpty from './nonempty.js';\nexport * as Schema from './schema.js';\n\n/**\n * Threads a value through a sequence of unary functions, left to right.\n * @param value - The initial value\n * @param fns - Functions to apply in order\n * @returns The result of applying all functions\n * @example\n * pipe(\n *   Result.tryCatch(() => JSON.parse(input)),\n *   r => Result.flatMap(r, validate),\n *   r => Result.map(r, transform),\n * )\n */\nexport function pipe<A>(a: A): A;\nexport function pipe<A, B>(a: A, ab: (a: A) => B): B;\nexport function pipe<A, B, C>(a: A, ab: (a: A) => B, bc: (b: B) => C): C;\nexport function pipe<A, B, C, D>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D): D;\nexport function pipe<A, B, C, D, E>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E): E;\nexport function pipe<A, B, C, D, E, F>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F): F;\nexport function pipe<A, B, C, D, E, F, G>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G): G;\nexport function pipe<A, B, C, D, E, F, G, H>(\n  a: A,\n  ab: (a: A) => B,\n  bc: (b: B) => C,\n  cd: (c: C) => D,\n  de: (d: D) => E,\n  ef: (e: E) => F,\n  fg: (f: F) => G,\n  gh: (g: G) => H,\n): H;\nexport function pipe<A, B, C, D, E, F, G, H, I>(\n  a: A,\n  ab: (a: A) => B,\n  bc: (b: B) => C,\n  cd: (c: C) => D,\n  de: (d: D) => E,\n  ef: (e: E) => F,\n  fg: (f: F) => G,\n  gh: (g: G) => H,\n  hi: (h: H) => I,\n): I;\nexport function pipe(a: unknown, ...fns: ((v: unknown) => unknown)[]): unknown {\n  let result = a;\n  for (let i = 0; i < fns.length; i++) {\n    result = fns[i](result);\n  }\n  return result;\n}\n"],"names":["Iter","NonEmpty","Option","Result","Schema","err","gen","genAsync","isErr","isNone","isOk","isSome","isSync","isThenable","none","ok","pipe","safeTry","safeTryAsync","some","unwrap","a","fns","result","i","length"],"mappings":";;;;;;;;;;;QAqBYA;;;QACAC;;;QAHAC;;;QACAC;;;QAGAC;;;QAvBaC;eAAAA,aAAG;;QAiBYC;eAAAA,cAAG;;QAAEC;eAAAA,mBAAQ;;QAjBjBC;eAAAA,eAAK;;QAAUC;eAAAA,gBAAM;;QAA3BC;eAAAA,cAAI;;QAASC;eAAAA,gBAAM;;QAAsBC;eAAAA,gBAAM;;QAAlBC;eAAAA,oBAAU;;QAAtDC;eAAAA,cAAI;;QAAEC;eAAAA,YAAE;;QAiEPC;eAAAA;;QAhDPC;eAAAA,kBAAO;;QAAEC;eAAAA,uBAAY;;QAjBrBC;eAAAA,cAAI;;QAiBmBC;eAAAA,iBAAM;;;0BAjB+C;mEAiBxB;mEAErC;iEAEF;qEACI;mEACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0CjB,SAASJ,KAAKK,CAAU,EAAE,GAAGC,GAAgC;IAClE,IAAIC,SAASF;IACb,IAAK,IAAIG,IAAI,GAAGA,IAAIF,IAAIG,MAAM,EAAED,IAAK;QACnCD,SAASD,GAAG,CAACE,EAAE,CAACD;IAClB;IACA,OAAOA;AACT"}

package/build/safe.d.ts

@@ -1,9 +1,12 @@
 export { some, none, ok, err, isOk, isErr, isSome, isNone, isThenable, isSync } from './types.js';
 export type { Some, None, Ok, Err, Option as OptionType, OptionValue, IsOption, InferSome, Result as ResultType, ResultValue, ResultErrorType, IsResult, InferErr, MaybePromise, } from './types.js';
 export { safeTry, safeTryAsync, unwrap, gen, genAsync } from './result.js';
+export type { NonEmptyArray, ReadonlyNonEmptyArray } from './nonempty.js';
 export * as Option from './option.js';
 export * as Result from './result.js';
 export * as Iter from './iter.js';
+export * as NonEmpty from './nonempty.js';
+export * as Schema from './schema.js';
 /**
  * Threads a value through a sequence of unary functions, left to right.
  * @param value - The initial value

package/build/safe.js

@@ -3,6 +3,8 @@ export { safeTry, safeTryAsync, unwrap, gen, genAsync } from "./result.js";
 export * as Option from "./option.js";
 export * as Result from "./result.js";
 export * as Iter from "./iter.js";
+export * as NonEmpty from "./nonempty.js";
+export * as Schema from "./schema.js";
 export function pipe(a, ...fns) {
     let result = a;
     for(let i = 0; i < fns.length; i++){

package/build/safe.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/safe.ts"],"sourcesContent":["export { some, none, ok, err, isOk, isErr, isSome, isNone, isThenable, isSync } from './types.js';\nexport type {\n  Some,\n  None,\n  Ok,\n  Err,\n  Option as OptionType,\n  OptionValue,\n  IsOption,\n  InferSome,\n  Result as ResultType,\n  ResultValue,\n  ResultErrorType,\n  IsResult,\n  InferErr,\n  MaybePromise,\n} from './types.js';\nexport { safeTry, safeTryAsync, unwrap, gen, genAsync } from './result.js';\nexport * as Option from './option.js';\nexport * as Result from './result.js';\nexport * as Iter from './iter.js';\n\n/**\n * Threads a value through a sequence of unary functions, left to right.\n * @param value - The initial value\n * @param fns - Functions to apply in order\n * @returns The result of applying all functions\n * @example\n * pipe(\n *   Result.tryCatch(() => JSON.parse(input)),\n *   r => Result.flatMap(r, validate),\n *   r => Result.map(r, transform),\n * )\n */\nexport function pipe<A>(a: A): A;\nexport function pipe<A, B>(a: A, ab: (a: A) => B): B;\nexport function pipe<A, B, C>(a: A, ab: (a: A) => B, bc: (b: B) => C): C;\nexport function pipe<A, B, C, D>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D): D;\nexport function pipe<A, B, C, D, E>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E): E;\nexport function pipe<A, B, C, D, E, F>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F): F;\nexport function pipe<A, B, C, D, E, F, G>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G): G;\nexport function pipe<A, B, C, D, E, F, G, H>(\n  a: A,\n  ab: (a: A) => B,\n  bc: (b: B) => C,\n  cd: (c: C) => D,\n  de: (d: D) => E,\n  ef: (e: E) => F,\n  fg: (f: F) => G,\n  gh: (g: G) => H,\n): H;\nexport function pipe<A, B, C, D, E, F, G, H, I>(\n  a: A,\n  ab: (a: A) => B,\n  bc: (b: B) => C,\n  cd: (c: C) => D,\n  de: (d: D) => E,\n  ef: (e: E) => F,\n  fg: (f: F) => G,\n  gh: (g: G) => H,\n  hi: (h: H) => I,\n): I;\nexport function pipe(a: unknown, ...fns: ((v: unknown) => unknown)[]): unknown {\n  let result = a;\n  for (let i = 0; i < fns.length; i++) {\n    result = fns[i](result);\n  }\n  return result;\n}\n"],"names":["some","none","ok","err","isOk","isErr","isSome","isNone","isThenable","isSync","safeTry","safeTryAsync","unwrap","gen","genAsync","Option","Result","Iter","pipe","a","fns","result","i","length"],"mappings":"AAAA,SAASA,IAAI,EAAEC,IAAI,EAAEC,EAAE,EAAEC,GAAG,EAAEC,IAAI,EAAEC,KAAK,EAAEC,MAAM,EAAEC,MAAM,EAAEC,UAAU,EAAEC,MAAM,QAAQ,aAAa;AAiBlG,SAASC,OAAO,EAAEC,YAAY,EAAEC,MAAM,EAAEC,GAAG,EAAEC,QAAQ,QAAQ,cAAc;AAC3E,OAAO,KAAKC,MAAM,MAAM,cAAc;AACtC,OAAO,KAAKC,MAAM,MAAM,cAAc;AACtC,OAAO,KAAKC,IAAI,MAAM,YAAY;AA0ClC,OAAO,SAASC,KAAKC,CAAU,EAAE,GAAGC,GAAgC;IAClE,IAAIC,SAASF;IACb,IAAK,IAAIG,IAAI,GAAGA,IAAIF,IAAIG,MAAM,EAAED,IAAK;QACnCD,SAASD,GAAG,CAACE,EAAE,CAACD;IAClB;IACA,OAAOA;AACT"}
+{"version":3,"sources":["../src/safe.ts"],"sourcesContent":["export { some, none, ok, err, isOk, isErr, isSome, isNone, isThenable, isSync } from './types.js';\nexport type {\n  Some,\n  None,\n  Ok,\n  Err,\n  Option as OptionType,\n  OptionValue,\n  IsOption,\n  InferSome,\n  Result as ResultType,\n  ResultValue,\n  ResultErrorType,\n  IsResult,\n  InferErr,\n  MaybePromise,\n} from './types.js';\nexport { safeTry, safeTryAsync, unwrap, gen, genAsync } from './result.js';\nexport type { NonEmptyArray, ReadonlyNonEmptyArray } from './nonempty.js';\nexport * as Option from './option.js';\nexport * as Result from './result.js';\nexport * as Iter from './iter.js';\nexport * as NonEmpty from './nonempty.js';\nexport * as Schema from './schema.js';\n\n/**\n * Threads a value through a sequence of unary functions, left to right.\n * @param value - The initial value\n * @param fns - Functions to apply in order\n * @returns The result of applying all functions\n * @example\n * pipe(\n *   Result.tryCatch(() => JSON.parse(input)),\n *   r => Result.flatMap(r, validate),\n *   r => Result.map(r, transform),\n * )\n */\nexport function pipe<A>(a: A): A;\nexport function pipe<A, B>(a: A, ab: (a: A) => B): B;\nexport function pipe<A, B, C>(a: A, ab: (a: A) => B, bc: (b: B) => C): C;\nexport function pipe<A, B, C, D>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D): D;\nexport function pipe<A, B, C, D, E>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E): E;\nexport function pipe<A, B, C, D, E, F>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F): F;\nexport function pipe<A, B, C, D, E, F, G>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G): G;\nexport function pipe<A, B, C, D, E, F, G, H>(\n  a: A,\n  ab: (a: A) => B,\n  bc: (b: B) => C,\n  cd: (c: C) => D,\n  de: (d: D) => E,\n  ef: (e: E) => F,\n  fg: (f: F) => G,\n  gh: (g: G) => H,\n): H;\nexport function pipe<A, B, C, D, E, F, G, H, I>(\n  a: A,\n  ab: (a: A) => B,\n  bc: (b: B) => C,\n  cd: (c: C) => D,\n  de: (d: D) => E,\n  ef: (e: E) => F,\n  fg: (f: F) => G,\n  gh: (g: G) => H,\n  hi: (h: H) => I,\n): I;\nexport function pipe(a: unknown, ...fns: ((v: unknown) => unknown)[]): unknown {\n  let result = a;\n  for (let i = 0; i < fns.length; i++) {\n    result = fns[i](result);\n  }\n  return result;\n}\n"],"names":["some","none","ok","err","isOk","isErr","isSome","isNone","isThenable","isSync","safeTry","safeTryAsync","unwrap","gen","genAsync","Option","Result","Iter","NonEmpty","Schema","pipe","a","fns","result","i","length"],"mappings":"AAAA,SAASA,IAAI,EAAEC,IAAI,EAAEC,EAAE,EAAEC,GAAG,EAAEC,IAAI,EAAEC,KAAK,EAAEC,MAAM,EAAEC,MAAM,EAAEC,UAAU,EAAEC,MAAM,QAAQ,aAAa;AAiBlG,SAASC,OAAO,EAAEC,YAAY,EAAEC,MAAM,EAAEC,GAAG,EAAEC,QAAQ,QAAQ,cAAc;AAE3E,OAAO,KAAKC,MAAM,MAAM,cAAc;AACtC,OAAO,KAAKC,MAAM,MAAM,cAAc;AACtC,OAAO,KAAKC,IAAI,MAAM,YAAY;AAClC,OAAO,KAAKC,QAAQ,MAAM,gBAAgB;AAC1C,OAAO,KAAKC,MAAM,MAAM,cAAc;AA0CtC,OAAO,SAASC,KAAKC,CAAU,EAAE,GAAGC,GAAgC;IAClE,IAAIC,SAASF;IACb,IAAK,IAAIG,IAAI,GAAGA,IAAIF,IAAIG,MAAM,EAAED,IAAK;QACnCD,SAASD,GAAG,CAACE,EAAE,CAACD;IAClB;IACA,OAAOA;AACT"}

package/build/schema.cjs

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get fromSchema () {
+        return fromSchema;
+    },
+    get wrapSchema () {
+        return wrapSchema;
+    }
+});
+const _typescjs = require("./types.cjs");
+function schemaResultToResult(sr) {
+    return sr.issues ? (0, _typescjs.err)(sr.issues) : sr.value;
+}
+function fromSchema(schema, value) {
+    const sr = schema['~standard'].validate(value);
+    if ((0, _typescjs.isThenable)(sr)) return sr.then(schemaResultToResult);
+    return schemaResultToResult(sr);
+}
+function wrapSchema(schema) {
+    return (value)=>fromSchema(schema, value);
+}
+
+//# sourceMappingURL=schema.cjs.map

package/build/schema.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/schema.ts"],"sourcesContent":["import { err as ERR, isThenable } from './types.js';\nimport type { Ok, Result } from './types.js';\n\n/** A validation issue from a Standard Schema validator. */\nexport interface SchemaIssue {\n  readonly message: string;\n  readonly path?: ReadonlyArray<PropertyKey | { readonly key: PropertyKey }>;\n}\n\n/** Minimal Standard Schema v1 interface (duck-typed, no external dependency). */\nexport interface StandardSchema<O = unknown> {\n  readonly '~standard': {\n    readonly validate: (value: unknown) => StandardSchemaResult<O> | Promise<StandardSchemaResult<O>>;\n  };\n}\n\ntype StandardSchemaResult<O> = { readonly value: O; readonly issues?: undefined } | { readonly issues: ReadonlyArray<SchemaIssue> };\n\nfunction schemaResultToResult<O>(sr: StandardSchemaResult<O>): Result<O, readonly SchemaIssue[]> {\n  return sr.issues ? ERR(sr.issues) : (sr.value as Ok<O>);\n}\n\n/**\n * Validates a value against a Standard Schema and returns a Result.\n * Works with any Standard Schema v1 compliant library (Zod, Valibot, ArkType, etc.).\n * Returns synchronously if the schema validates synchronously.\n * @param schema - A Standard Schema v1 compliant schema\n * @param value - The value to validate\n * @returns Ok(parsed) if valid, Err(issues) if invalid\n * @example\n * import { z } from 'zod';\n * const result = fromSchema(z.string().email(), input);\n * // Result<string, readonly SchemaIssue[]>\n */\nexport function fromSchema<O>(schema: StandardSchema<O>, value: unknown): Result<O, readonly SchemaIssue[]> | Promise<Result<O, readonly SchemaIssue[]>> {\n  const sr = schema['~standard'].validate(value);\n  if (isThenable(sr)) return sr.then(schemaResultToResult);\n  return schemaResultToResult(sr);\n}\n\n/**\n * Binds a Standard Schema once and returns a reusable validator function.\n * The partial-application form of fromSchema - validate many values against one schema.\n * @param schema - A Standard Schema v1 compliant schema\n * @returns A function that validates a value and returns a Result\n * @example\n * const parseUser = wrapSchema(userSchema);\n * const result = parseUser(input); // Result<User, readonly SchemaIssue[]>\n */\nexport function wrapSchema<O>(schema: StandardSchema<O>): (value: unknown) => Result<O, readonly SchemaIssue[]> | Promise<Result<O, readonly SchemaIssue[]>> {\n  return (value) => fromSchema(schema, value);\n}\n"],"names":["fromSchema","wrapSchema","schemaResultToResult","sr","issues","ERR","value","schema","validate","isThenable","then"],"mappings":";;;;;;;;;;;QAkCgBA;eAAAA;;QAeAC;eAAAA;;;0BAjDuB;AAkBvC,SAASC,qBAAwBC,EAA2B;IAC1D,OAAOA,GAAGC,MAAM,GAAGC,IAAAA,aAAG,EAACF,GAAGC,MAAM,IAAKD,GAAGG,KAAK;AAC/C;AAcO,SAASN,WAAcO,MAAyB,EAAED,KAAc;IACrE,MAAMH,KAAKI,MAAM,CAAC,YAAY,CAACC,QAAQ,CAACF;IACxC,IAAIG,IAAAA,oBAAU,EAACN,KAAK,OAAOA,GAAGO,IAAI,CAACR;IACnC,OAAOA,qBAAqBC;AAC9B;AAWO,SAASF,WAAcM,MAAyB;IACrD,OAAO,CAACD,QAAUN,WAAWO,QAAQD;AACvC"}

package/build/schema.d.ts

@@ -0,0 +1,44 @@
+import type { Result } from './types.js';
+/** A validation issue from a Standard Schema validator. */
+export interface SchemaIssue {
+    readonly message: string;
+    readonly path?: ReadonlyArray<PropertyKey | {
+        readonly key: PropertyKey;
+    }>;
+}
+/** Minimal Standard Schema v1 interface (duck-typed, no external dependency). */
+export interface StandardSchema<O = unknown> {
+    readonly '~standard': {
+        readonly validate: (value: unknown) => StandardSchemaResult<O> | Promise<StandardSchemaResult<O>>;
+    };
+}
+type StandardSchemaResult<O> = {
+    readonly value: O;
+    readonly issues?: undefined;
+} | {
+    readonly issues: ReadonlyArray<SchemaIssue>;
+};
+/**
+ * Validates a value against a Standard Schema and returns a Result.
+ * Works with any Standard Schema v1 compliant library (Zod, Valibot, ArkType, etc.).
+ * Returns synchronously if the schema validates synchronously.
+ * @param schema - A Standard Schema v1 compliant schema
+ * @param value - The value to validate
+ * @returns Ok(parsed) if valid, Err(issues) if invalid
+ * @example
+ * import { z } from 'zod';
+ * const result = fromSchema(z.string().email(), input);
+ * // Result<string, readonly SchemaIssue[]>
+ */
+export declare function fromSchema<O>(schema: StandardSchema<O>, value: unknown): Result<O, readonly SchemaIssue[]> | Promise<Result<O, readonly SchemaIssue[]>>;
+/**
+ * Binds a Standard Schema once and returns a reusable validator function.
+ * The partial-application form of fromSchema - validate many values against one schema.
+ * @param schema - A Standard Schema v1 compliant schema
+ * @returns A function that validates a value and returns a Result
+ * @example
+ * const parseUser = wrapSchema(userSchema);
+ * const result = parseUser(input); // Result<User, readonly SchemaIssue[]>
+ */
+export declare function wrapSchema<O>(schema: StandardSchema<O>): (value: unknown) => Result<O, readonly SchemaIssue[]> | Promise<Result<O, readonly SchemaIssue[]>>;
+export {};

package/build/schema.js

@@ -0,0 +1,14 @@
+import { err as ERR, isThenable } from "./types.js";
+function schemaResultToResult(sr) {
+    return sr.issues ? ERR(sr.issues) : sr.value;
+}
+export function fromSchema(schema, value) {
+    const sr = schema['~standard'].validate(value);
+    if (isThenable(sr)) return sr.then(schemaResultToResult);
+    return schemaResultToResult(sr);
+}
+export function wrapSchema(schema) {
+    return (value)=>fromSchema(schema, value);
+}
+
+//# sourceMappingURL=schema.js.map

package/build/schema.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/schema.ts"],"sourcesContent":["import { err as ERR, isThenable } from './types.js';\nimport type { Ok, Result } from './types.js';\n\n/** A validation issue from a Standard Schema validator. */\nexport interface SchemaIssue {\n  readonly message: string;\n  readonly path?: ReadonlyArray<PropertyKey | { readonly key: PropertyKey }>;\n}\n\n/** Minimal Standard Schema v1 interface (duck-typed, no external dependency). */\nexport interface StandardSchema<O = unknown> {\n  readonly '~standard': {\n    readonly validate: (value: unknown) => StandardSchemaResult<O> | Promise<StandardSchemaResult<O>>;\n  };\n}\n\ntype StandardSchemaResult<O> = { readonly value: O; readonly issues?: undefined } | { readonly issues: ReadonlyArray<SchemaIssue> };\n\nfunction schemaResultToResult<O>(sr: StandardSchemaResult<O>): Result<O, readonly SchemaIssue[]> {\n  return sr.issues ? ERR(sr.issues) : (sr.value as Ok<O>);\n}\n\n/**\n * Validates a value against a Standard Schema and returns a Result.\n * Works with any Standard Schema v1 compliant library (Zod, Valibot, ArkType, etc.).\n * Returns synchronously if the schema validates synchronously.\n * @param schema - A Standard Schema v1 compliant schema\n * @param value - The value to validate\n * @returns Ok(parsed) if valid, Err(issues) if invalid\n * @example\n * import { z } from 'zod';\n * const result = fromSchema(z.string().email(), input);\n * // Result<string, readonly SchemaIssue[]>\n */\nexport function fromSchema<O>(schema: StandardSchema<O>, value: unknown): Result<O, readonly SchemaIssue[]> | Promise<Result<O, readonly SchemaIssue[]>> {\n  const sr = schema['~standard'].validate(value);\n  if (isThenable(sr)) return sr.then(schemaResultToResult);\n  return schemaResultToResult(sr);\n}\n\n/**\n * Binds a Standard Schema once and returns a reusable validator function.\n * The partial-application form of fromSchema - validate many values against one schema.\n * @param schema - A Standard Schema v1 compliant schema\n * @returns A function that validates a value and returns a Result\n * @example\n * const parseUser = wrapSchema(userSchema);\n * const result = parseUser(input); // Result<User, readonly SchemaIssue[]>\n */\nexport function wrapSchema<O>(schema: StandardSchema<O>): (value: unknown) => Result<O, readonly SchemaIssue[]> | Promise<Result<O, readonly SchemaIssue[]>> {\n  return (value) => fromSchema(schema, value);\n}\n"],"names":["err","ERR","isThenable","schemaResultToResult","sr","issues","value","fromSchema","schema","validate","then","wrapSchema"],"mappings":"AAAA,SAASA,OAAOC,GAAG,EAAEC,UAAU,QAAQ,aAAa;AAkBpD,SAASC,qBAAwBC,EAA2B;IAC1D,OAAOA,GAAGC,MAAM,GAAGJ,IAAIG,GAAGC,MAAM,IAAKD,GAAGE,KAAK;AAC/C;AAcA,OAAO,SAASC,WAAcC,MAAyB,EAAEF,KAAc;IACrE,MAAMF,KAAKI,MAAM,CAAC,YAAY,CAACC,QAAQ,CAACH;IACxC,IAAIJ,WAAWE,KAAK,OAAOA,GAAGM,IAAI,CAACP;IACnC,OAAOA,qBAAqBC;AAC9B;AAWA,OAAO,SAASO,WAAcH,MAAyB;IACrD,OAAO,CAACF,QAAUC,WAAWC,QAAQF;AACvC"}

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "nalloc",
   "description": "Rust-like Option and Result for TypeScript with near-zero allocations for extreme performance",
-  "version": "0.2.2",
+  "version": "0.5.0",
   "type": "module",
   "types": "build/index.d.ts",
   "main": "build/index.cjs",
   "module": "build/index.js",
+  "sideEffects": false,
   "exports": {
     ".": {
       "require": "./build/index.cjs",
@@ -23,6 +24,10 @@
       "require": "./build/result.cjs",
       "import": "./build/result.js"
     },
+    "./schema": {
+      "require": "./build/schema.cjs",
+      "import": "./build/schema.js"
+    },
     "./safe": {
       "require": "./build/safe.cjs",
       "import": "./build/safe.js"
@@ -35,8 +40,27 @@
       "require": "./build/iter.cjs",
       "import": "./build/iter.js"
     },
+    "./nonempty": {
+      "require": "./build/nonempty.cjs",
+      "import": "./build/nonempty.js"
+    },
+    "./http": {
+      "require": "./build/http.cjs",
+      "import": "./build/http.js"
+    },
+    "./eslint": {
+      "require": "./build/eslint.cjs",
+      "import": "./build/eslint.js"
+    },
+    "./codemod": {
+      "require": "./build/codemod.cjs",
+      "import": "./build/codemod.js"
+    },
     "./package.json": "./package.json"
   },
+  "bin": {
+    "nalloc-codemod": "./build/codemod-cli.js"
+  },
   "files": [
     "build",
     "src"
@@ -54,6 +78,8 @@
     "err",
     "some",
     "none",
+    "nonempty",
+    "non-empty-array",
     "unwrap",
     "rust",
     "typescript",
@@ -91,24 +117,51 @@
     "url": "https://github.com/3axap4eHko/nalloc/issues"
   },
   "homepage": "https://github.com/3axap4eHko/nalloc#readme",
+  "peerDependencies": {
+    "@typescript-eslint/parser": ">=8",
+    "@typescript-eslint/utils": ">=8",
+    "eslint": ">=9",
+    "oxc-parser": ">=0.135.0",
+    "typescript": ">=4.8.4"
+  },
+  "peerDependenciesMeta": {
+    "@typescript-eslint/parser": {
+      "optional": true
+    },
+    "@typescript-eslint/utils": {
+      "optional": true
+    },
+    "eslint": {
+      "optional": true
+    },
+    "oxc-parser": {
+      "optional": true
+    },
+    "typescript": {
+      "optional": true
+    }
+  },
   "devDependencies": {
-    "@eslint/js": "^10.0.1",
-    "@vitest/coverage-v8": "^4.1.2",
-    "eslint": "^10.2.0",
-    "eslint-plugin-prettier": "^5.5.5",
+    "@types/node": "^25.9.3",
+    "@typescript-eslint/parser": "^8.61.1",
+    "@typescript-eslint/rule-tester": "^8.61.1",
+    "@typescript-eslint/utils": "^8.61.1",
+    "@vitest/coverage-v8": "^4.1.9",
     "inop": "^0.9.0",
     "overtake": "^2.1.1",
-    "prettier": "^3.8.1",
+    "oxc-parser": "^0.136.0",
+    "oxlint": "^1.70.0",
+    "prettier": "^3.8.4",
     "tsafe": "^1.8.12",
     "tslib": "^2.8.1",
-    "typescript": "^6.0.2",
-    "typescript-eslint": "^8.58.0",
-    "vitest": "^4.1.2"
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.9"
   },
   "scripts": {
     "check": "tsc --noEmit -p tsconfig.check.json",
     "build": "rm -rf build && inop src build -i __tests__ -i *.tmp.ts && tsc --declaration --emitDeclarationOnly",
-    "lint": "eslint .",
+    "lint": "oxlint",
+    "format": "prettier --check .",
     "test": "vitest run",
     "bench": "overtake benchmarks/* --pin-cores -w 1 --progress",
     "bench:save": "pnpm bench --save-baseline .bench-baseline.json",

package/src/__tests__/codemod.ts

@@ -0,0 +1,211 @@
+import { describe, it, expect } from 'vitest';
+import { migrateSource, renderReport } from '../codemod.js';
+
+function migrate(source: string): ReturnType<typeof migrateSource> {
+  return migrateSource(source, 'fixture.ts');
+}
+
+describe('codemod', () => {
+  it('leaves files without neverthrow imports untouched', () => {
+    const source = `const xs = [1, 2].map(x => x * 2);\n`;
+    const result = migrate(source);
+    expect(result.changed).toBe(false);
+    expect(result.output).toBe(source);
+    expect(result.skipped).toEqual([]);
+  });
+
+  it('rewrites the import and converts provenant single-method calls', () => {
+    const source = [
+      `import { ok, err } from 'neverthrow';`,
+      `const r = ok(1);`,
+      `const d = r.map(x => x + 1);`,
+      `const e = d.andThen(x => x > 0 ? ok(x) : err('neg'));`,
+    ].join('\n');
+    const result = migrate(source);
+    expect(result.changed).toBe(true);
+    expect(result.output).toContain(`import { ok, err, Result } from 'nalloc';`);
+    expect(result.output).toContain(`const d = Result.map(r, x => x + 1);`);
+    expect(result.output).toContain(`const e = Result.flatMap(d, x => x > 0 ? ok(x) : err('neg'));`);
+    expect(result.output).not.toContain('neverthrow');
+    expect(result.skipped).toEqual([]);
+  });
+
+  it('preserves import aliases', () => {
+    const source = [`import { ok as okay } from 'neverthrow';`, `const r = okay(1);`, `const d = r.map(x => x + 1);`].join('\n');
+    const result = migrate(source);
+    expect(result.output).toContain(`import { ok as okay, Result } from 'nalloc';`);
+    expect(result.output).toContain(`Result.map(r, x => x + 1)`);
+  });
+
+  it('folds chains of two or more methods into pipe', () => {
+    const source = [`import { ok } from 'neverthrow';`, `const out = ok(1).map(a => a + 1).mapErr(String).unwrapOr(0);`].join('\n');
+    const result = migrate(source);
+    expect(result.output).toContain(`import { ok, Result, pipe } from 'nalloc';`);
+    expect(result.output).toContain(
+      `const out = pipe(ok(1), ($r) => Result.map($r, a => a + 1), ($r) => Result.mapErr($r, String), ($r) => Result.unwrapOr($r, 0));`,
+    );
+  });
+
+  it('does not touch bare .map calls without provenance', () => {
+    const source = [
+      `import { ok } from 'neverthrow';`,
+      `const xs = [1, 2].map(x => x * 2);`,
+      `declare const unknownValue: { map(fn: (x: number) => number): number[] };`,
+      `unknownValue.map(x => x);`,
+    ].join('\n');
+    const result = migrate(source);
+    expect(result.output).toContain(`[1, 2].map(x => x * 2)`);
+    expect(result.output).toContain(`unknownValue.map(x => x)`);
+  });
+
+  it('converts neverthrow-exclusive methods without provenance', () => {
+    const source = [`import { ok } from 'neverthrow';`, `declare const foreign: any;`, `const r = foreign.andThen((x: number) => ok(x));`].join('\n');
+    const result = migrate(source);
+    expect(result.output).toContain(`Result.flatMap(foreign, (x: number) => ok(x))`);
+  });
+
+  it('uses type annotations from neverthrow imports as provenance and renames the Result type', () => {
+    const source = [
+      `import { ok, Result } from 'neverthrow';`,
+      `const t: Result<number, string> = ok(2);`,
+      `const u = t.map(x => x * 2);`,
+      `function f(input: Result<number, string>): Result<number, string> { return input.mapErr(e => e); }`,
+    ].join('\n');
+    const result = migrate(source);
+    expect(result.output).toContain(`import { ok, Result, type ResultType } from 'nalloc';`);
+    expect(result.output).toContain(`const t: ResultType<number, string> = ok(2);`);
+    expect(result.output).toContain(`Result.map(t, x => x * 2)`);
+    expect(result.output).toContain(`function f(input: ResultType<number, string>): ResultType<number, string> { return Result.mapErr(input, e => e); }`);
+  });
+
+  it('converts fromThrowable to Result.wrap and tracks wrapped functions as provenance', () => {
+    const source = [
+      `import { fromThrowable } from 'neverthrow';`,
+      `const safeParse = fromThrowable(JSON.parse);`,
+      `const p = safeParse('{}');`,
+      `const q = p.map(v => v);`,
+    ].join('\n');
+    const result = migrate(source);
+    expect(result.output).toContain(`const safeParse = Result.wrap(JSON.parse);`);
+    expect(result.output).toContain(`Result.map(p, v => v)`);
+    expect(result.output).not.toContain('neverthrow');
+  });
+
+  it('converts combine and combineWithAllErrors including Result statics', () => {
+    const source = [
+      `import { ok, combine, Result } from 'neverthrow';`,
+      `const a = combine([ok(1), ok(2)]);`,
+      `const b = Result.combineWithAllErrors([ok(1)]);`,
+      `const c = Result.fromThrowable(JSON.parse);`,
+    ].join('\n');
+    const result = migrate(source);
+    expect(result.output).toContain(`const a = Result.all([ok(1), ok(2)]);`);
+    expect(result.output).toContain(`const b = Result.collectAll([ok(1)]);`);
+    expect(result.output).toContain(`const c = Result.wrap(JSON.parse);`);
+  });
+
+  it('converts directly-awaited fromPromise and treats its result as migrated', () => {
+    const source = [
+      `import { fromPromise } from 'neverthrow';`,
+      `async function run(p: Promise<number>) {`,
+      `  const r = await fromPromise(p, e => String(e));`,
+      `  return r.map(x => x + 1);`,
+      `}`,
+    ].join('\n');
+    const result = migrate(source);
+    expect(result.output).toContain(`await Result.fromPromise(p, e => String(e))`);
+    expect(result.output).toContain(`Result.map(r, x => x + 1)`);
+    expect(result.skipped).toEqual([]);
+    expect(result.output).not.toContain('neverthrow');
+  });
+
+  it('reports chained fromPromise as result-async and keeps the neverthrow import', () => {
+    const source = [`import { fromPromise } from 'neverthrow';`, `const ra = fromPromise(Promise.resolve(1), e => e).map(x => x);`].join('\n');
+    const result = migrate(source);
+    expect(result.skipped.map((s) => s.reason)).toContain('result-async');
+    expect(result.output).toContain(`import { fromPromise } from 'neverthrow';`);
+    expect(result.output).toContain(`fromPromise(Promise.resolve(1), e => e).map(x => x)`);
+  });
+
+  it('reports ResultAsync values and never converts methods on them', () => {
+    const source = [
+      `import { okAsync } from 'neverthrow';`,
+      `const ra = okAsync(1);`,
+      `const rb = ra.map(x => x + 1);`,
+      `async function f() { const r = await ra; return r.mapErr(e => e); }`,
+    ].join('\n');
+    const result = migrate(source);
+    expect(result.output).toContain(`const rb = ra.map(x => x + 1);`);
+    expect(result.output).toContain(`return r.mapErr(e => e);`);
+    expect(result.output).toContain(`import { okAsync } from 'neverthrow';`);
+    expect(result.skipped.some((s) => s.reason === 'result-async')).toBe(true);
+  });
+
+  it('reports safeTry for manual gen migration', () => {
+    const source = [`import { ok, safeTry } from 'neverthrow';`, `const r = safeTry(function* () { return ok(1); });`].join('\n');
+    const result = migrate(source);
+    expect(result.skipped.map((s) => s.reason)).toContain('safe-try');
+    expect(result.output).toContain(`import { safeTry } from 'neverthrow';`);
+  });
+
+  it('refuses whole chains containing unsupported methods', () => {
+    const source = [`import { ok } from 'neverthrow';`, `const r = ok(1).andThrough(x => ok(x)).map(x => x + 1);`].join('\n');
+    const result = migrate(source);
+    expect(result.skipped.map((s) => s.reason)).toContain('unsupported');
+    expect(result.output).toContain(`ok(1).andThrough(x => ok(x)).map(x => x + 1)`);
+  });
+
+  it('skips namespace imports entirely', () => {
+    const source = [`import * as nt from 'neverthrow';`, `const r = nt.ok(1);`].join('\n');
+    const result = migrate(source);
+    expect(result.changed).toBe(false);
+    expect(result.skipped.map((s) => s.reason)).toEqual(['namespace-import']);
+  });
+
+  it('converts nested chains inside chain arguments', () => {
+    const source = [`import { ok, err } from 'neverthrow';`, `const inner = ok(2);`, `const r = ok(1).andThen(x => inner.mapErr(e => e)).map(x => x);`].join(
+      '\n',
+    );
+    const result = migrate(source);
+    expect(result.output).toContain(`pipe(ok(1), ($r) => Result.flatMap($r, x => Result.mapErr(inner, e => e)), ($r) => Result.map($r, x => x))`);
+  });
+
+  it('converts match and unwrap accessors', () => {
+    const source = [
+      `import { ok } from 'neverthrow';`,
+      `const r = ok(1);`,
+      `const m = r.match(x => x, e => 0);`,
+      `const v = r._unsafeUnwrap();`,
+      `const o = r.isOk();`,
+    ].join('\n');
+    const result = migrate(source);
+    expect(result.output).toContain(`const m = Result.match(r, x => x, e => 0);`);
+    expect(result.output).toContain(`const v = Result.unwrap(r);`);
+    expect(result.output).toContain(`const o = Result.isOk(r);`);
+  });
+
+  it('drops provenance for conflicting bindings', () => {
+    const source = [
+      `import { ok } from 'neverthrow';`,
+      `function a() { const v = ok(1); return v; }`,
+      `function b() { const v = [1, 2]; return v.map(x => x); }`,
+    ].join('\n');
+    const result = migrate(source);
+    expect(result.output).toContain(`return v.map(x => x);`);
+  });
+
+  it('renders a grouped markdown report', () => {
+    const report = renderReport({
+      filesChanged: 1,
+      converted: 3,
+      skipped: [
+        { file: 'a.ts', line: 2, reason: 'result-async', text: 'okAsync(1)' },
+        { file: 'a.ts', line: 5, reason: 'safe-try', text: 'safeTry(fn)' },
+      ],
+    });
+    expect(report).toContain('# nalloc migration report');
+    expect(report).toContain('Files changed: 1. Sites converted: 3. Sites needing manual review: 2.');
+    expect(report).toContain('## a.ts');
+    expect(report).toContain('- line 2 [result-async]: `okAsync(1)`');
+  });
+});

package/src/__tests__/eslint.ts

@@ -0,0 +1,99 @@
+import { describe, it, expect } from 'vitest';
+import * as path from 'node:path';
+import { RuleTester } from '@typescript-eslint/rule-tester';
+import plugin, { rules, mustUse, noUnwrap } from '../eslint.js';
+
+describe('eslint plugin', () => {
+  it('exposes both rules with create + meta', () => {
+    for (const name of ['must-use', 'no-unwrap'] as const) {
+      expect(typeof rules[name].create).toBe('function');
+      expect(rules[name].meta.messages).toBeTypeOf('object');
+    }
+  });
+
+  it('wires the recommended config', () => {
+    expect(plugin.meta.name).toBe('nalloc');
+    const recommended = plugin.configs.recommended as { plugins: Record<string, unknown>; rules: Record<string, string> };
+    expect(recommended.plugins.nalloc).toBe(plugin);
+    expect(recommended.rules['nalloc/must-use']).toBe('error');
+    expect(recommended.rules['nalloc/no-unwrap']).toBe('error');
+  });
+});
+
+const typedTester = new RuleTester({
+  languageOptions: {
+    parserOptions: {
+      projectService: { allowDefaultProject: ['*.ts*'] },
+      tsconfigRootDir: path.join(import.meta.dirname, 'fixtures'),
+    },
+  },
+});
+
+typedTester.run('must-use', mustUse, {
+  valid: [
+    `type Result<T, E> = readonly [T] | { error: E }; declare function f(): Result<number, string>; const r = f();`,
+    `declare function g(): number; g();`,
+    `type Foo<T> = readonly [T]; declare function f(): Foo<number>; f();`,
+    {
+      code: `type Result<T, E> = readonly [T] | { error: E }; declare function f(): Result<number, string>; f();`,
+      options: [{ typeNames: ['Option'] }],
+    },
+  ],
+  invalid: [
+    {
+      code: `type Result<T, E> = readonly [T] | { error: E }; declare function f(): Result<number, string>; f();`,
+      errors: [{ messageId: 'mustUse', data: { name: 'Result' } }],
+    },
+    {
+      code: `type Option<T> = T | undefined; declare function f(): Option<number>; f();`,
+      errors: [{ messageId: 'mustUse', data: { name: 'Option' } }],
+    },
+    {
+      code: `type Result<T, E> = readonly [T] | { error: E }; declare function f(): Promise<Result<number, string>>; async function run() { await f(); }`,
+      errors: [{ messageId: 'mustUse', data: { name: 'Result' } }],
+    },
+    {
+      code: `type Mine<T> = readonly [T]; declare function f(): Mine<number>; f();`,
+      options: [{ typeNames: ['Mine'] }],
+      errors: [{ messageId: 'mustUse', data: { name: 'Mine' } }],
+    },
+  ],
+});
+
+const tester = new RuleTester({ languageOptions: { parserOptions: { sourceType: 'module' } } });
+
+tester.run('no-unwrap', noUnwrap, {
+  valid: [
+    `import { unwrap } from 'other-lib'; declare const r: unknown; unwrap(r);`,
+    `import { Result } from 'nalloc'; declare const r: unknown; Result.unwrapOr(r, 0);`,
+    `const Result = { unwrap(x: unknown) { return x; } }; Result.unwrap(1);`,
+    `function unwrap(x: unknown) { return x; } unwrap(1);`,
+  ],
+  invalid: [
+    {
+      code: `import { unwrap } from 'nalloc'; declare const r: unknown; unwrap(r);`,
+      errors: [{ messageId: 'noUnwrap', data: { name: 'unwrap' } }],
+    },
+    {
+      code: `import { Result } from 'nalloc'; declare const r: unknown; Result.unwrap(r);`,
+      errors: [{ messageId: 'noUnwrap', data: { name: 'unwrap' } }],
+    },
+    {
+      code: `import { Option } from 'nalloc'; declare const o: unknown; Option.expect(o, 'm');`,
+      errors: [{ messageId: 'noUnwrap', data: { name: 'expect' } }],
+    },
+    {
+      code: `import { Result } from 'nalloc'; declare const r: unknown; Result.unwrapErr(r);`,
+      errors: [{ messageId: 'noUnwrap', data: { name: 'unwrapErr' } }],
+    },
+    {
+      code: `import { unwrap as uw } from 'nalloc'; declare const r: unknown; uw(r);`,
+      errors: [{ messageId: 'noUnwrap', data: { name: 'unwrap' } }],
+    },
+    {
+      code: `import { unwrap } from '@me/x'; declare const r: unknown; unwrap(r);`,
+      options: [{ modules: ['@me/x'] }],
+      errors: [{ messageId: 'noUnwrap', data: { name: 'unwrap' } }],
+    },
+  ],
+});

package/src/__tests__/fixtures/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "compilerOptions": {
+    "strict": true,
+    "target": "esnext",
+    "module": "preserve",
+    "moduleResolution": "bundler",
+    "skipLibCheck": true,
+    "noEmit": true
+  }
+}