@design-edito/tools 0.3.2 → 0.3.4

package/node/images/format/index.js

@@ -1,115 +1,98 @@
-import {
-  toSharpColor,
-  toSharpInstance
-} from "../../../chunks/chunk-6KOJFWH3.js";
-import {
-  zod_default
-} from "../../../chunks/chunk-LFHDJTZJ.js";
-import {
-  makeSuccess
-} from "../../../chunks/chunk-QEKI6WGQ.js";
-import "../../../chunks/chunk-RNXRHCHQ.js";
-import "../../../chunks/chunk-DNIOWD7K.js";
-import {
-  clamp
-} from "../../../chunks/chunk-OSAXBA7G.js";
-import {
-  isColor
-} from "../../../chunks/chunk-JDINERKY.js";
-import "../../../chunks/chunk-HQLRJ7XW.js";
-import "../../../chunks/chunk-KRYJVBO5.js";
-import "../../../chunks/chunk-XCBH6NLF.js";
-
 // src/node/images/format/index.ts
-var formatCommonOptionsSchema = zod_default.object({
-  width: zod_default.number().optional(),
-  height: zod_default.number().optional(),
-  fit: zod_default.enum(["contain", "cover", "fill", "inside", "outside"]).optional(),
-  position: zod_default.union([zod_default.number(), zod_default.string()]).optional(),
-  background: zod_default.custom(isColor).optional(),
-  kernel: zod_default.enum(["nearest", "cubic", "mitchell", "lanczos2", "lanczos3", "mks2013", "mks2021"]).optional(),
-  withoutEnlargement: zod_default.boolean().optional(),
-  withoutReduction: zod_default.boolean().optional(),
-  fastShrinkOnLoad: zod_default.boolean().optional()
+import zod from "zod";
+import { clamp } from "../../../agnostic/numbers/clamp/index.js";
+import * as Outcome from "../../../agnostic/misc/outcome/index.js";
+import { toSharpColor, toSharpInstance } from "../utils/index.js";
+import { isColor } from "../../../agnostic/colors/typechecks/index.js";
+var formatCommonOptionsSchema = zod.object({
+  width: zod.number().optional(),
+  height: zod.number().optional(),
+  fit: zod.enum(["contain", "cover", "fill", "inside", "outside"]).optional(),
+  position: zod.union([zod.number(), zod.string()]).optional(),
+  background: zod.custom(isColor).optional(),
+  kernel: zod.enum(["nearest", "cubic", "mitchell", "lanczos2", "lanczos3", "mks2013", "mks2021"]).optional(),
+  withoutEnlargement: zod.boolean().optional(),
+  withoutReduction: zod.boolean().optional(),
+  fastShrinkOnLoad: zod.boolean().optional()
 });
 var formatJpgOptionsSchema = formatCommonOptionsSchema.extend({
-  type: zod_default.union([zod_default.literal("jpg"), zod_default.literal("jpeg")]),
-  quality: zod_default.number().optional(),
-  force: zod_default.boolean().optional(),
-  progressive: zod_default.boolean().optional(),
-  chromaSubsampling: zod_default.string().optional(),
-  trellisQuantisation: zod_default.boolean().optional(),
-  overshootDeringing: zod_default.boolean().optional(),
-  optimizeScans: zod_default.boolean().optional(),
-  optimizeCoding: zod_default.boolean().optional(),
-  quantizationTable: zod_default.number().optional(),
-  mozjpeg: zod_default.boolean().optional()
+  type: zod.union([zod.literal("jpg"), zod.literal("jpeg")]),
+  quality: zod.number().optional(),
+  force: zod.boolean().optional(),
+  progressive: zod.boolean().optional(),
+  chromaSubsampling: zod.string().optional(),
+  trellisQuantisation: zod.boolean().optional(),
+  overshootDeringing: zod.boolean().optional(),
+  optimizeScans: zod.boolean().optional(),
+  optimizeCoding: zod.boolean().optional(),
+  quantizationTable: zod.number().optional(),
+  mozjpeg: zod.boolean().optional()
 });
 var formatPngOptionsSchema = formatCommonOptionsSchema.extend({
-  type: zod_default.literal("png"),
-  quality: zod_default.number().optional(),
-  force: zod_default.boolean().optional(),
-  progressive: zod_default.boolean().optional(),
-  compressionLevel: zod_default.number().min(0).max(9).optional(),
-  adaptiveFiltering: zod_default.boolean().optional(),
-  effort: zod_default.number().min(1).max(10).optional(),
-  palette: zod_default.boolean().optional(),
-  colors: zod_default.number().min(1).max(256).optional(),
-  dither: zod_default.number().min(0).max(1).optional()
+  type: zod.literal("png"),
+  quality: zod.number().optional(),
+  force: zod.boolean().optional(),
+  progressive: zod.boolean().optional(),
+  compressionLevel: zod.number().min(0).max(9).optional(),
+  adaptiveFiltering: zod.boolean().optional(),
+  effort: zod.number().min(1).max(10).optional(),
+  palette: zod.boolean().optional(),
+  colors: zod.number().min(1).max(256).optional(),
+  dither: zod.number().min(0).max(1).optional()
 });
 var formatWebpOptionsSchema = formatCommonOptionsSchema.extend({
-  type: zod_default.literal("webp"),
-  quality: zod_default.number().optional(),
-  force: zod_default.boolean().optional(),
-  alphaQuality: zod_default.number().optional(),
-  lossless: zod_default.boolean().optional(),
-  nearLossless: zod_default.boolean().optional(),
-  smartSubsample: zod_default.boolean().optional(),
-  smartDeblock: zod_default.boolean().optional(),
-  effort: zod_default.number().optional(),
-  minSize: zod_default.boolean().optional(),
-  mixed: zod_default.boolean().optional(),
-  preset: zod_default.enum(["default", "picture", "photo", "drawing", "icon", "text"]).optional(),
-  loop: zod_default.number().optional(),
-  delay: zod_default.union([zod_default.number(), zod_default.array(zod_default.number())]).optional()
+  type: zod.literal("webp"),
+  quality: zod.number().optional(),
+  force: zod.boolean().optional(),
+  alphaQuality: zod.number().optional(),
+  lossless: zod.boolean().optional(),
+  nearLossless: zod.boolean().optional(),
+  smartSubsample: zod.boolean().optional(),
+  smartDeblock: zod.boolean().optional(),
+  effort: zod.number().optional(),
+  minSize: zod.boolean().optional(),
+  mixed: zod.boolean().optional(),
+  preset: zod.enum(["default", "picture", "photo", "drawing", "icon", "text"]).optional(),
+  loop: zod.number().optional(),
+  delay: zod.union([zod.number(), zod.array(zod.number())]).optional()
 });
 var formatAvifOptionsSchema = formatCommonOptionsSchema.extend({
-  type: zod_default.literal("avif"),
-  quality: zod_default.number().optional(),
-  force: zod_default.boolean().optional(),
-  lossless: zod_default.boolean().optional(),
-  effort: zod_default.number().optional(),
-  chromaSubsampling: zod_default.string().optional(),
-  bitdepth: zod_default.union([zod_default.literal(8), zod_default.literal(10), zod_default.literal(12)]).optional()
+  type: zod.literal("avif"),
+  quality: zod.number().optional(),
+  force: zod.boolean().optional(),
+  lossless: zod.boolean().optional(),
+  effort: zod.number().optional(),
+  chromaSubsampling: zod.string().optional(),
+  bitdepth: zod.union([zod.literal(8), zod.literal(10), zod.literal(12)]).optional()
 });
 var formatTiffOptionsSchema = formatCommonOptionsSchema.extend({
-  type: zod_default.literal("tiff"),
-  quality: zod_default.number().optional(),
-  compression: zod_default.enum(["none", "jpeg", "deflate", "packbits", "ccittfax4", "lzw", "webp", "zstd", "jp2k"]).optional(),
-  force: zod_default.boolean().optional(),
-  predictor: zod_default.enum(["none", "horizontal", "float"]).optional(),
-  pyramid: zod_default.boolean().optional(),
-  tile: zod_default.boolean().optional(),
-  tileWidth: zod_default.number().optional(),
-  tileHeight: zod_default.number().optional(),
-  xres: zod_default.number().optional(),
-  yres: zod_default.number().optional(),
-  bitdepth: zod_default.union([zod_default.literal(1), zod_default.literal(2), zod_default.literal(4), zod_default.literal(8)]).optional(),
-  miniswhite: zod_default.boolean().optional(),
-  resolutionUnit: zod_default.enum(["inch", "cm"]).optional()
+  type: zod.literal("tiff"),
+  quality: zod.number().optional(),
+  compression: zod.enum(["none", "jpeg", "deflate", "packbits", "ccittfax4", "lzw", "webp", "zstd", "jp2k"]).optional(),
+  force: zod.boolean().optional(),
+  predictor: zod.enum(["none", "horizontal", "float"]).optional(),
+  pyramid: zod.boolean().optional(),
+  tile: zod.boolean().optional(),
+  tileWidth: zod.number().optional(),
+  tileHeight: zod.number().optional(),
+  xres: zod.number().optional(),
+  yres: zod.number().optional(),
+  bitdepth: zod.union([zod.literal(1), zod.literal(2), zod.literal(4), zod.literal(8)]).optional(),
+  miniswhite: zod.boolean().optional(),
+  resolutionUnit: zod.enum(["inch", "cm"]).optional()
 });
 var formatHeifOptionsSchema = formatCommonOptionsSchema.extend({
-  type: zod_default.literal("heif"),
-  quality: zod_default.number().optional(),
-  force: zod_default.boolean().optional(),
-  compression: zod_default.enum(["av1", "hevc"]).optional(),
-  lossless: zod_default.boolean().optional(),
-  effort: zod_default.number().optional(),
-  chromaSubsampling: zod_default.string().optional(),
-  bitdepth: zod_default.union([zod_default.literal(8), zod_default.literal(10), zod_default.literal(12)]).optional()
+  type: zod.literal("heif"),
+  quality: zod.number().optional(),
+  force: zod.boolean().optional(),
+  compression: zod.enum(["av1", "hevc"]).optional(),
+  lossless: zod.boolean().optional(),
+  effort: zod.number().optional(),
+  chromaSubsampling: zod.string().optional(),
+  bitdepth: zod.union([zod.literal(8), zod.literal(10), zod.literal(12)]).optional()
 });
 var formatKeepOptionsSchema = formatCommonOptionsSchema;
-var formatOptionsSchema = zod_default.union([
+var formatOptionsSchema = zod.union([
   formatJpgOptionsSchema,
   formatPngOptionsSchema,
   formatWebpOptionsSchema,
@@ -225,13 +208,13 @@ async function format(input, options) {
   const sharpInstance = await toSharpInstance(input);
   const resizeOptions = toSharpResizeOptions(options);
   const resizedInstance = sharpInstance.resize(resizeOptions);
-  if (isFormatJpgOptions(options)) return makeSuccess(await resizedInstance.jpeg(toSharpJpegOptions(options)).toBuffer());
-  if (isFormatPngOptions(options)) return makeSuccess(await resizedInstance.png(toSharpPngOptions(options)).toBuffer());
-  if (isFormatWebpOptions(options)) return makeSuccess(await resizedInstance.webp(toSharpWebpOptions(options)).toBuffer());
-  if (isFormatAvifOptions(options)) return makeSuccess(await resizedInstance.avif(toSharpAvifOptions(options)).toBuffer());
-  if (isFormatTiffOptions(options)) return makeSuccess(await resizedInstance.tiff(toSharpTiffOptions(options)).toBuffer());
-  if (isFormatHeifOptions(options)) return makeSuccess(await resizedInstance.heif(toSharpHeifOptions(options)).toBuffer());
-  return makeSuccess(await resizedInstance.toBuffer());
+  if (isFormatJpgOptions(options)) return Outcome.makeSuccess(await resizedInstance.jpeg(toSharpJpegOptions(options)).toBuffer());
+  if (isFormatPngOptions(options)) return Outcome.makeSuccess(await resizedInstance.png(toSharpPngOptions(options)).toBuffer());
+  if (isFormatWebpOptions(options)) return Outcome.makeSuccess(await resizedInstance.webp(toSharpWebpOptions(options)).toBuffer());
+  if (isFormatAvifOptions(options)) return Outcome.makeSuccess(await resizedInstance.avif(toSharpAvifOptions(options)).toBuffer());
+  if (isFormatTiffOptions(options)) return Outcome.makeSuccess(await resizedInstance.tiff(toSharpTiffOptions(options)).toBuffer());
+  if (isFormatHeifOptions(options)) return Outcome.makeSuccess(await resizedInstance.heif(toSharpHeifOptions(options)).toBuffer());
+  return Outcome.makeSuccess(await resizedInstance.toBuffer());
 }
 var toWidth = async (input, width) => (await toSharpInstance(input)).resize({ width }).toBuffer();
 var toHeight = async (input, height) => (await toSharpInstance(input)).resize({ height }).toBuffer();

package/node/images/metadata/index.js

@@ -1,15 +1,5 @@
-import {
-  toSharpInstance
-} from "../../../chunks/chunk-6KOJFWH3.js";
-import "../../../chunks/chunk-RNXRHCHQ.js";
-import "../../../chunks/chunk-DNIOWD7K.js";
-import "../../../chunks/chunk-OSAXBA7G.js";
-import "../../../chunks/chunk-JDINERKY.js";
-import "../../../chunks/chunk-HQLRJ7XW.js";
-import "../../../chunks/chunk-KRYJVBO5.js";
-import "../../../chunks/chunk-XCBH6NLF.js";
-
 // src/node/images/metadata/index.ts
+import { toSharpInstance } from "../utils/index.js";
 async function metadata(imageInput) {
   const sharpInstance = await toSharpInstance(imageInput);
   return sharpInstance.metadata();

package/node/images/transform/index.js

@@ -1,113 +1,56 @@
-import {
-  isSaturateOperationParams,
-  saturate
-} from "../../../chunks/chunk-AYGAQQXD.js";
-import {
-  isResizeOperationParams,
-  resize
-} from "../../../chunks/chunk-FXISVWGE.js";
-import {
-  isOverlayOperationParams,
-  overlay
-} from "../../../chunks/chunk-MZYCKOLN.js";
-import {
-  isRotateOperationParams,
-  rotate
-} from "../../../chunks/chunk-QFBVETGF.js";
-import {
-  extract,
-  isExtractOperationParams
-} from "../../../chunks/chunk-NR7STUY3.js";
-import {
-  flatten,
-  isFlattenOperationParams
-} from "../../../chunks/chunk-HMPY32F7.js";
-import {
-  flip
-} from "../../../chunks/chunk-WNDMYNDU.js";
-import {
-  flop
-} from "../../../chunks/chunk-YA2YCZUF.js";
-import {
-  hue,
-  isHueOperationParams
-} from "../../../chunks/chunk-ASWI3EO6.js";
-import {
-  isLightenOperationParams,
-  lighten
-} from "../../../chunks/chunk-65BFQP3T.js";
-import {
-  isLevelOperationParams,
-  level
-} from "../../../chunks/chunk-IK2S6ZYP.js";
-import {
-  isNormalizeOperationParams,
-  normalize
-} from "../../../chunks/chunk-MHNUCHPP.js";
-import {
-  blur,
-  isBlurOperationParams
-} from "../../../chunks/chunk-PTJO2TGI.js";
-import {
-  brighten,
-  isBrightenOperationParams
-} from "../../../chunks/chunk-5CFQCSKJ.js";
-import {
-  extend,
-  isExtendOperationParams
-} from "../../../chunks/chunk-TLWVLCIQ.js";
-import {
-  toSharpInstance
-} from "../../../chunks/chunk-6KOJFWH3.js";
-import "../../../chunks/chunk-LFHDJTZJ.js";
-import "../../../chunks/chunk-5NTPCRFH.js";
-import {
-  unknownToString
-} from "../../../chunks/chunk-FENXVJYO.js";
-import {
-  makeFailure,
-  makeSuccess
-} from "../../../chunks/chunk-QEKI6WGQ.js";
-import "../../../chunks/chunk-RNXRHCHQ.js";
-import "../../../chunks/chunk-DNIOWD7K.js";
-import "../../../chunks/chunk-OSAXBA7G.js";
-import "../../../chunks/chunk-JDINERKY.js";
-import {
-  isNonNullObject
-} from "../../../chunks/chunk-HQLRJ7XW.js";
-import "../../../chunks/chunk-KRYJVBO5.js";
-import "../../../chunks/chunk-XCBH6NLF.js";
-
 // src/node/images/transform/index.ts
+import * as Outcome from "../../../agnostic/misc/outcome/index.js";
+import { unknownToString } from "../../../agnostic/errors/unknown-to-string/index.js";
+import { isNonNullObject } from "../../../agnostic/objects/is-object/index.js";
+import {
+  OpName,
+  TransformErrCodes
+} from "../types.js";
+import { toSharpInstance } from "../utils/index.js";
+import { blur, isBlurOperationParams } from "./operations/blur/index.js";
+import { brighten, isBrightenOperationParams } from "./operations/brighten/index.js";
+import { extend, isExtendOperationParams } from "./operations/extend/index.js";
+import { extract, isExtractOperationParams } from "./operations/extract/index.js";
+import { flatten, isFlattenOperationParams } from "./operations/flatten/index.js";
+import { flip } from "./operations/flip/index.js";
+import { flop } from "./operations/flop/index.js";
+import { hue, isHueOperationParams } from "./operations/hue/index.js";
+import { level, isLevelOperationParams } from "./operations/level/index.js";
+import { lighten, isLightenOperationParams } from "./operations/lighten/index.js";
+import { normalize, isNormalizeOperationParams } from "./operations/normalize/index.js";
+import { overlay, isOverlayOperationParams } from "./operations/overlay/index.js";
+import { resize, isResizeOperationParams } from "./operations/resize/index.js";
+import { rotate, isRotateOperationParams } from "./operations/rotate/index.js";
+import { saturate, isSaturateOperationParams } from "./operations/saturate/index.js";
 var validators = {
-  ["blur" /* BLUR */]: isBlurOperationParams,
-  ["brighten" /* BRIGHTEN */]: isBrightenOperationParams,
-  ["extend" /* EXTEND */]: isExtendOperationParams,
-  ["extract" /* EXTRACT */]: isExtractOperationParams,
-  ["flatten" /* FLATTEN */]: isFlattenOperationParams,
-  ["hue" /* HUE */]: isHueOperationParams,
-  ["level" /* LEVEL */]: isLevelOperationParams,
-  ["lighten" /* LIGHTEN */]: isLightenOperationParams,
-  ["normalize" /* NORMALIZE */]: isNormalizeOperationParams,
-  ["overlay" /* OVERLAY */]: isOverlayOperationParams,
-  ["resize" /* RESIZE */]: isResizeOperationParams,
-  ["rotate" /* ROTATE */]: isRotateOperationParams,
-  ["saturate" /* SATURATE */]: isSaturateOperationParams
+  [OpName.BLUR]: isBlurOperationParams,
+  [OpName.BRIGHTEN]: isBrightenOperationParams,
+  [OpName.EXTEND]: isExtendOperationParams,
+  [OpName.EXTRACT]: isExtractOperationParams,
+  [OpName.FLATTEN]: isFlattenOperationParams,
+  [OpName.HUE]: isHueOperationParams,
+  [OpName.LEVEL]: isLevelOperationParams,
+  [OpName.LIGHTEN]: isLightenOperationParams,
+  [OpName.NORMALIZE]: isNormalizeOperationParams,
+  [OpName.OVERLAY]: isOverlayOperationParams,
+  [OpName.RESIZE]: isResizeOperationParams,
+  [OpName.ROTATE]: isRotateOperationParams,
+  [OpName.SATURATE]: isSaturateOperationParams
 };
 function isOperationDescriptor(obj) {
-  if (!isNonNullObject(obj)) return makeFailure("Invalid operation descriptor");
-  if (!("name" in obj) || typeof obj.name !== "string") return makeFailure("Field named 'name' in operation descriptor is required and must be a string");
+  if (!isNonNullObject(obj)) return Outcome.makeFailure("Invalid operation descriptor");
+  if (!("name" in obj) || typeof obj.name !== "string") return Outcome.makeFailure("Field named 'name' in operation descriptor is required and must be a string");
   const name = obj.name;
   const validateOperation = (validatorFn) => {
     const result = validatorFn(obj);
-    if (result.success) return makeSuccess({ name: obj.name, ...result.payload });
-    return makeFailure(result.error);
+    if (result.success) return Outcome.makeSuccess({ name: obj.name, ...result.payload });
+    return Outcome.makeFailure(result.error);
   };
-  const simpleOperations = /* @__PURE__ */ new Set(["flip" /* FLIP */, "flop" /* FLOP */]);
-  if (simpleOperations.has(name)) return makeSuccess({ name });
+  const simpleOperations = /* @__PURE__ */ new Set([OpName.FLIP, OpName.FLOP]);
+  if (simpleOperations.has(name)) return Outcome.makeSuccess({ name });
   const validator = validators[name];
   if (validator) return validateOperation(validator);
-  return makeFailure("Invalid operation descriptor");
+  return Outcome.makeFailure("Invalid operation descriptor");
 }
 async function transform(input, operationsSequence, limits) {
   let sharpInstance = await toSharpInstance(input);
@@ -116,88 +59,88 @@ async function transform(input, operationsSequence, limits) {
   const runWithOpTimeout = async (op) => {
     return limits?.opTimeoutMs === void 0 ? op() : Promise.race([op(), new Promise(
       (resolve) => setTimeout(
-        () => resolve("op-timeout" /* OP_TIMEOUT */),
+        () => resolve(TransformErrCodes.OP_TIMEOUT),
         limits.opTimeoutMs
       )
     )]);
   };
   for (const operation of operationsSequence) {
-    if (deadline !== void 0 && Date.now() > deadline) return makeFailure({
-      code: "process-timeout" /* PROCESS_TIMEOUT */,
+    if (deadline !== void 0 && Date.now() > deadline) return Outcome.makeFailure({
+      code: TransformErrCodes.PROCESS_TIMEOUT,
       details: "Process timed out"
     });
     let result;
     try {
       result = await runWithOpTimeout(async () => {
         switch (operation.name) {
-          case "blur" /* BLUR */:
+          case OpName.BLUR:
             return blur(sharpInstance, operation);
-          case "brighten" /* BRIGHTEN */:
+          case OpName.BRIGHTEN:
             return brighten(sharpInstance, operation);
-          case "extend" /* EXTEND */:
+          case OpName.EXTEND:
             return extend(sharpInstance, operation);
-          case "extract" /* EXTRACT */:
+          case OpName.EXTRACT:
             return extract(sharpInstance, operation);
-          case "flatten" /* FLATTEN */:
+          case OpName.FLATTEN:
             return flatten(sharpInstance, operation);
-          case "flip" /* FLIP */:
+          case OpName.FLIP:
             return flip(sharpInstance);
-          case "flop" /* FLOP */:
+          case OpName.FLOP:
             return flop(sharpInstance);
-          case "hue" /* HUE */:
+          case OpName.HUE:
             return hue(sharpInstance, operation);
-          case "level" /* LEVEL */:
+          case OpName.LEVEL:
             return level(sharpInstance, operation);
-          case "lighten" /* LIGHTEN */:
+          case OpName.LIGHTEN:
             return lighten(sharpInstance, operation);
-          case "normalize" /* NORMALIZE */:
+          case OpName.NORMALIZE:
             return normalize(sharpInstance, operation);
-          case "overlay" /* OVERLAY */:
+          case OpName.OVERLAY:
             return overlay(sharpInstance, operation);
-          case "resize" /* RESIZE */:
+          case OpName.RESIZE:
             return resize(sharpInstance, operation);
-          case "rotate" /* ROTATE */:
+          case OpName.ROTATE:
             return rotate(sharpInstance, operation);
-          case "saturate" /* SATURATE */:
+          case OpName.SATURATE:
             return saturate(sharpInstance, operation);
           default:
             return sharpInstance;
         }
       });
     } catch (err) {
-      return makeFailure({
-        code: "unknown-error" /* UNKNOWN_ERROR */,
+      return Outcome.makeFailure({
+        code: TransformErrCodes.UNKNOWN_ERROR,
         details: unknownToString(err)
       });
     }
-    if (result === "op-timeout" /* OP_TIMEOUT */) return makeFailure({
-      code: "op-timeout" /* OP_TIMEOUT */,
+    if (result === TransformErrCodes.OP_TIMEOUT) return Outcome.makeFailure({
+      code: TransformErrCodes.OP_TIMEOUT,
       details: "Operation timed out"
     });
     else {
       sharpInstance = result;
     }
     if (limits === void 0) continue;
-    if (operation.name === "resize" /* RESIZE */ || operation.name === "extend" /* EXTEND */ || operation.name === "extract" /* EXTRACT */ || operation.name === "rotate" /* ROTATE */) {
+    if (operation.name === OpName.RESIZE || operation.name === OpName.EXTEND || operation.name === OpName.EXTRACT || operation.name === OpName.ROTATE) {
       try {
         const meta = await sharpInstance.metadata();
-        if (limits.width !== void 0 && meta.width && meta.width > limits.width) return makeFailure({
-          code: "width-limit-exceeded" /* WIDTH_LIMIT_EXCEEDED */,
+        if (limits.width !== void 0 && meta.width && meta.width > limits.width) return Outcome.makeFailure({
+          code: TransformErrCodes.WIDTH_LIMIT_EXCEEDED,
           details: `Image width exceeded the limit (${meta.width}px)`
         });
-        if (limits.height !== void 0 && meta.height && meta.height > limits.height) return makeFailure({
-          code: "height-limit-exceeded" /* HEIGHT_LIMIT_EXCEEDED */,
+        if (limits.height !== void 0 && meta.height && meta.height > limits.height) return Outcome.makeFailure({
+          code: TransformErrCodes.HEIGHT_LIMIT_EXCEEDED,
           details: `Image height exceeded the limit (${meta.height}px)`
         });
       } catch (err) {
-        return makeFailure({
-          code: "unknown-error" /* UNKNOWN_ERROR */,
+        return Outcome.makeFailure({
+          code: TransformErrCodes.UNKNOWN_ERROR,
           details: `Failed to read metadata: ${unknownToString(err)}`
         });
       }
     }
   }
-  return makeSuccess(sharpInstance);
+  return Outcome.makeSuccess(sharpInstance);
 }
 export {
   isOperationDescriptor,

package/node/images/transform/operations/blur/index.js

@@ -1,10 +1,15 @@
-import {
-  blur,
-  isBlurOperationParams
-} from "../../../../../chunks/chunk-PTJO2TGI.js";
-import "../../../../../chunks/chunk-LFHDJTZJ.js";
-import "../../../../../chunks/chunk-QEKI6WGQ.js";
-import "../../../../../chunks/chunk-XCBH6NLF.js";
+// src/node/images/transform/operations/blur/index.ts
+import z from "zod";
+import * as Outcome from "../../../../../agnostic/misc/outcome/index.js";
+function isBlurOperationParams(obj) {
+  const schema = z.object({ sigma: z.number() });
+  const result = schema.safeParse(obj);
+  if (!result.success) return Outcome.makeFailure(result.error.message);
+  return Outcome.makeSuccess(result.data);
+}
+async function blur(sharpInstance, params) {
+  return sharpInstance.blur(params.sigma);
+}
 export {
   blur,
   isBlurOperationParams

package/node/images/transform/operations/brighten/index.js

@@ -1,10 +1,15 @@
-import {
-  brighten,
-  isBrightenOperationParams
-} from "../../../../../chunks/chunk-5CFQCSKJ.js";
-import "../../../../../chunks/chunk-LFHDJTZJ.js";
-import "../../../../../chunks/chunk-QEKI6WGQ.js";
-import "../../../../../chunks/chunk-XCBH6NLF.js";
+// src/node/images/transform/operations/brighten/index.ts
+import z from "zod";
+import * as Outcome from "../../../../../agnostic/misc/outcome/index.js";
+function isBrightenOperationParams(obj) {
+  const schema = z.object({ factor: z.number() });
+  const result = schema.safeParse(obj);
+  if (!result.success) return Outcome.makeFailure(result.error.message);
+  return Outcome.makeSuccess(result.data);
+}
+async function brighten(sharpInstance, params) {
+  return sharpInstance.modulate({ brightness: params.factor });
+}
 export {
   brighten,
   isBrightenOperationParams

package/node/images/transform/operations/extend/index.js

@@ -1,17 +1,27 @@
-import {
-  extend,
-  isExtendOperationParams
-} from "../../../../../chunks/chunk-TLWVLCIQ.js";
-import "../../../../../chunks/chunk-6KOJFWH3.js";
-import "../../../../../chunks/chunk-LFHDJTZJ.js";
-import "../../../../../chunks/chunk-QEKI6WGQ.js";
-import "../../../../../chunks/chunk-RNXRHCHQ.js";
-import "../../../../../chunks/chunk-DNIOWD7K.js";
-import "../../../../../chunks/chunk-OSAXBA7G.js";
-import "../../../../../chunks/chunk-JDINERKY.js";
-import "../../../../../chunks/chunk-HQLRJ7XW.js";
-import "../../../../../chunks/chunk-KRYJVBO5.js";
-import "../../../../../chunks/chunk-XCBH6NLF.js";
+// src/node/images/transform/operations/extend/index.ts
+import z from "zod";
+import * as Outcome from "../../../../../agnostic/misc/outcome/index.js";
+import { isColor } from "../../../../../agnostic/colors/typechecks/index.js";
+import { toSharpColor } from "../../../utils/index.js";
+function isExtendOperationParams(obj) {
+  const schema = z.object({
+    left: z.number().optional(),
+    right: z.number().optional(),
+    top: z.number().optional(),
+    bottom: z.number().optional(),
+    extendWith: z.optional(z.enum(["background", "copy", "repeat", "mirror"])),
+    background: z.custom(isColor).optional()
+  });
+  const result = schema.safeParse(obj);
+  if (!result.success) return Outcome.makeFailure(result.error.message);
+  return Outcome.makeSuccess(result.data);
+}
+async function extend(sharpInstance, params) {
+  return sharpInstance.extend({
+    ...params,
+    background: params.background !== void 0 ? toSharpColor(params.background) : void 0
+  });
+}
 export {
   extend,
   isExtendOperationParams

package/node/images/transform/operations/extract/index.js

@@ -1,10 +1,20 @@
-import {
-  extract,
-  isExtractOperationParams
-} from "../../../../../chunks/chunk-NR7STUY3.js";
-import "../../../../../chunks/chunk-LFHDJTZJ.js";
-import "../../../../../chunks/chunk-QEKI6WGQ.js";
-import "../../../../../chunks/chunk-XCBH6NLF.js";
+// src/node/images/transform/operations/extract/index.ts
+import z from "zod";
+import * as Outcome from "../../../../../agnostic/misc/outcome/index.js";
+function isExtractOperationParams(obj) {
+  const schema = z.object({
+    left: z.number(),
+    top: z.number(),
+    width: z.number(),
+    height: z.number()
+  });
+  const result = schema.safeParse(obj);
+  if (!result.success) return Outcome.makeFailure(result.error.message);
+  return Outcome.makeSuccess(result.data);
+}
+async function extract(sharpInstance, params) {
+  return sharpInstance.extract(params);
+}
 export {
   extract,
   isExtractOperationParams