@beeintel/batch-image 0.0.0-stage → 1.0.0

package/dist/types/batch/api.d.ts

@@ -0,0 +1,89 @@
+import { type LirSegmentSubmission } from './features/listing-remake/transport';
+import type { WorkspaceServices, WorkspaceTaskSubmission, WorkspaceServiceSource, WorkspaceUploadOptions } from './public/service-contracts';
+export type TaskService = 'node' | 'python-ai';
+export declare class ApiError extends Error {
+    code: string;
+    accepted: boolean | 'unknown';
+    retryAfterMs?: number;
+    constructor(code: string, message: string, accepted?: boolean | 'unknown', retryAfterMs?: number);
+}
+/** A separate immutable client is captured by every instance; there is no ambient transport. */
+export declare function createWorkspaceServiceClient(services?: WorkspaceServices): {
+    getCapabilities: () => Promise<{
+        storage: "local" | "r2";
+        taskPersistence: "local_disk";
+        authentication: "loopback_only";
+        idempotencyRetention: "local_state_lifetime";
+        uploadStatus: boolean;
+        maxItems: number;
+        maxUploadBytes: number;
+        maxPixels: number;
+        tools: string[];
+        metadataExport: boolean;
+        assetRetentionHours: number;
+    }>;
+    getAiCapabilities: () => Promise<{
+        taskService: "python-ai";
+        queue: "sqlite-huey";
+        taskPersistence: "sqlite";
+        idempotencyRetention: "local_state_lifetime";
+        executor: "rembg" | "fixture";
+        tools: string[];
+        cutoutModels: string[];
+        retouchModes: string[];
+        upscaleModes: string[];
+        svgEngines: string[];
+        beautificationModes: string[];
+        lir: {
+            maxReferenceImages: number;
+            maxAcceptedTasks: number;
+            serviceEpoch: string;
+        };
+    }>;
+    uploadLocal: (blob: Blob, filename: string, options?: WorkspaceUploadOptions) => Promise<import("./model").Asset>;
+    resolveAsset: (assetId: string, versionId: string) => Promise<import("./model").Asset>;
+    submitTask: (submission: WorkspaceTaskSubmission) => Promise<import("./receipts").TaskResponse>;
+    queryOriginalTask: (taskId: string) => Promise<import("./receipts").TaskResponse>;
+    getTask: (taskId: string, service?: TaskService) => Promise<import("./receipts").TaskResponse>;
+    getTaskByRequest: (clientRequestId: string, service?: TaskService) => Promise<import("./receipts").TaskResponse>;
+    submitLirSegment: (body: LirSegmentSubmission) => Promise<{
+        segmentId: string;
+        tasks: import("./receipts").TaskResponse[];
+    }>;
+    exportDeclaredImage: (source: WorkspaceServiceSource, format: "png" | "jpeg", expectedSha256: string, service?: TaskService) => Promise<Blob>;
+    fetchExternalSource: (url: string, expectedSha256?: string, signal?: AbortSignal) => Promise<Blob>;
+    fetchExternalThumbnail: (url: string, expectedSha256?: string) => Promise<Blob>;
+};
+export declare const getCapabilities: () => Promise<{
+    storage: "local" | "r2";
+    taskPersistence: "local_disk";
+    authentication: "loopback_only";
+    idempotencyRetention: "local_state_lifetime";
+    uploadStatus: boolean;
+    maxItems: number;
+    maxUploadBytes: number;
+    maxPixels: number;
+    tools: string[];
+    metadataExport: boolean;
+    assetRetentionHours: number;
+}>, getAiCapabilities: () => Promise<{
+    taskService: "python-ai";
+    queue: "sqlite-huey";
+    taskPersistence: "sqlite";
+    idempotencyRetention: "local_state_lifetime";
+    executor: "rembg" | "fixture";
+    tools: string[];
+    cutoutModels: string[];
+    retouchModes: string[];
+    upscaleModes: string[];
+    svgEngines: string[];
+    beautificationModes: string[];
+    lir: {
+        maxReferenceImages: number;
+        maxAcceptedTasks: number;
+        serviceEpoch: string;
+    };
+}>, uploadLocal: (blob: Blob, filename: string, options?: WorkspaceUploadOptions) => Promise<import("./model").Asset>, resolveAsset: (assetId: string, versionId: string) => Promise<import("./model").Asset>, submitTask: (submission: WorkspaceTaskSubmission) => Promise<import("./receipts").TaskResponse>, submitLirSegment: (body: LirSegmentSubmission) => Promise<{
+    segmentId: string;
+    tasks: import("./receipts").TaskResponse[];
+}>, getTask: (taskId: string, service?: TaskService) => Promise<import("./receipts").TaskResponse>, queryOriginalTask: (taskId: string) => Promise<import("./receipts").TaskResponse>, getTaskByRequest: (clientRequestId: string, service?: TaskService) => Promise<import("./receipts").TaskResponse>, exportDeclaredImage: (source: WorkspaceServiceSource, format: "png" | "jpeg", expectedSha256: string, service?: TaskService) => Promise<Blob>, fetchExternalSource: (url: string, expectedSha256?: string, signal?: AbortSignal) => Promise<Blob>, fetchExternalThumbnail: (url: string, expectedSha256?: string) => Promise<Blob>;

package/dist/types/batch/cutout-output.d.ts

@@ -0,0 +1,2 @@
+export declare function processCutoutResult(blob: Blob, params: Readonly<Record<string, unknown>>, signal?: AbortSignal): Promise<Blob>;
+export declare function deriveCutoutCanvas(input: OffscreenCanvas, trimTransparent?: boolean, background?: string, padding?: number): OffscreenCanvas;

package/dist/types/batch/features/background/engine.d.mts

@@ -0,0 +1,12 @@
+export interface BackgroundParams {
+  color: string;
+}
+export function validateBackground(value: unknown): BackgroundParams;
+export function backgroundPixels(
+  rgba: Uint8ClampedArray,
+  width: number,
+  height: number,
+  params: BackgroundParams,
+):
+  | { kind: 'image'; data: Uint8ClampedArray; width: number; height: number }
+  | { kind: 'analysis'; skipped: true; reason: string };

package/dist/types/batch/features/basic-edit/contracts.d.ts

@@ -0,0 +1,87 @@
+export interface AdjustParams {
+    version: 1;
+    brightness: number;
+    contrast: number;
+    saturation: number;
+    vibrance: number;
+    temperature: number;
+    tint: number;
+}
+/** Numeric components are constrained to positive integers 1..4096 by validateCrop. */
+export type CropRatio = 'original' | 'alpha-bounds' | `${number}:${number}`;
+export type CropAnchor = 'top-left' | 'top' | 'top-right' | 'left' | 'center' | 'right' | 'bottom-left' | 'bottom' | 'bottom-right';
+export interface CropParams {
+    version: 1;
+    ratio: CropRatio;
+    anchor: CropAnchor;
+    padding?: number;
+    paddingColor?: 'transparent' | `#${string}`;
+}
+export interface CropRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export type AlphaCropBounds = {
+    kind: 'crop';
+    rect: CropRect;
+} | {
+    kind: 'skip';
+    reason: 'fully-transparent' | 'no-transparent-border';
+};
+export type AlphaTrimGeometry = {
+    kind: 'skip';
+    reason: 'fully-transparent' | 'no-transparent-border' | 'unchanged-padding';
+} | {
+    kind: 'render';
+    sourceRect: CropRect;
+    width: number;
+    height: number;
+    padding: number;
+};
+export type AlphaTrimPixels = Extract<AlphaTrimGeometry, {
+    kind: 'skip';
+}> | {
+    kind: 'image';
+    data: Uint8ClampedArray;
+    width: number;
+    height: number;
+};
+export type ResizeParams = {
+    original: true;
+} | {
+    width: number;
+    height: number;
+    fit: 'contain' | 'cover';
+    background: 'transparent' | `#${string}`;
+    position?: CropAnchor;
+    allowEnlargement?: boolean;
+    kernel?: 'lanczos3' | 'mitchell' | 'cubic' | 'linear';
+};
+export interface ResizeGeometry {
+    width: number;
+    height: number;
+    /** Continuous scaled source rectangle on the output canvas, including cover overflow. */
+    imageRect: CropRect;
+    /** Enlargement was disabled and the requested fit would scale this source above 1. */
+    skipped?: true;
+}
+export interface OrientParams {
+    version: 1;
+    upright: boolean;
+    rotation: 0 | 90 | 180 | 270;
+    flipHorizontal: boolean;
+    flipVertical: boolean;
+}
+export interface OrientedPixels {
+    data: Uint8ClampedArray;
+    width: number;
+    height: number;
+}
+/** SVG coefficients: x'=a*x+c*y, y'=b*x+d*y, about image center. */
+export interface OrientationDisplayTransform {
+    width: number;
+    height: number;
+    matrix: [number, number, number, number];
+}

package/dist/types/batch/features/basic-edit/engine.d.mts

@@ -0,0 +1,96 @@
+import type {
+  AdjustParams,
+  CropParams,
+  CropRect,
+  AlphaCropBounds,
+  AlphaTrimGeometry,
+  AlphaTrimPixels,
+  OrientParams,
+  OrientedPixels,
+  OrientationDisplayTransform,
+  ResizeParams,
+  ResizeGeometry,
+} from './contracts';
+export type {
+  AdjustParams,
+  CropParams,
+  CropRect,
+  CropRatio,
+  CropAnchor,
+  OrientParams,
+  OrientedPixels,
+  OrientationDisplayTransform,
+  ResizeParams,
+  ResizeGeometry,
+} from './contracts';
+
+export const DEFAULT_ADJUST: Readonly<AdjustParams>;
+export const DEFAULT_CROP: Readonly<CropParams>;
+export function validateAdjust(value: unknown): AdjustParams;
+export function validateCrop(value: unknown): CropParams;
+export function validateTrimPadding(value: unknown): number;
+export function alphaTrimGeometry(
+  bounds: AlphaCropBounds,
+  width: number,
+  height: number,
+  padding?: number,
+): AlphaTrimGeometry;
+export function trimAlphaPixels(
+  rgba: Uint8ClampedArray,
+  width: number,
+  height: number,
+  padding?: number,
+  paddingColor?: CropParams['paddingColor'],
+): AlphaTrimPixels;
+export function isNeutralAdjustment(params: AdjustParams): boolean;
+export function adjustPixels(
+  rgba: Uint8ClampedArray,
+  width: number,
+  height: number,
+  params: AdjustParams,
+): Uint8ClampedArray;
+export function computeCropRect(width: number, height: number, params: CropParams): CropRect;
+export function computeAlphaCropRect(
+  rgba: Uint8ClampedArray,
+  width: number,
+  height: number,
+): AlphaCropBounds;
+export function cropPixels(
+  rgba: Uint8ClampedArray,
+  width: number,
+  height: number,
+  rect: CropRect,
+): Uint8ClampedArray;
+export function validateResize(value: unknown): ResizeParams;
+/** Continuous geometry; disabled required enlargement returns source identity with skipped:true. */
+export function computeResizeGeometry(
+  sourceWidth: number,
+  sourceHeight: number,
+  params: ResizeParams,
+): ResizeGeometry;
+
+export const DEFAULT_ORIENT: Readonly<OrientParams>;
+export function validateOrient(value: unknown): OrientParams;
+/** Manual rotation/flip composition only; source EXIF is the decoder's responsibility. */
+export function isNeutralOrient(params: OrientParams): boolean;
+export function orientPixels(
+  rgba: Uint8ClampedArray,
+  width: number,
+  height: number,
+  params: OrientParams,
+): OrientedPixels;
+/** Raw decoded pixels from an EXIF-neutralized preview copy; apply EXIF/manual transforms once. */
+export function orientRawPixels(
+  rgba: Uint8ClampedArray,
+  width: number,
+  height: number,
+  params: OrientParams,
+  sourceExifOrientation: number,
+): OrientedPixels;
+/** Input is an already upright DOM image; disabling upright requires EXIF 1–8. */
+export function orientationDisplayTransform(
+  width: number,
+  height: number,
+  params: OrientParams,
+  sourceExifOrientation?: number,
+): OrientationDisplayTransform;

package/dist/types/batch/features/brand-mark/contracts.d.ts

@@ -0,0 +1,84 @@
+import type { CropAnchor } from '../basic-edit/contracts';
+export type BrandMarkAnchor = CropAnchor;
+export interface BrandLogoIdentity {
+    assetId: string;
+    assetVersionId: string;
+    sha256: string;
+}
+export type BrandMarkMode = 'single' | 'tile';
+export type BrandTileDensity = 'sparse' | 'standard' | 'dense';
+export type BrandTileDirection = 'diagonal' | 'horizontal';
+export interface SingleBrandMarkOptions {
+    version: 1;
+    anchor: BrandMarkAnchor;
+    sizePercent: number;
+    marginPercent: number;
+    opacity: number;
+    mode?: 'single';
+}
+export interface TileBrandMarkOptions {
+    version: 1;
+    mode: 'tile';
+    sizePercent: number;
+    opacity: number;
+    density: number;
+    angle: number;
+    anchor?: BrandMarkAnchor;
+    marginPercent?: number;
+}
+export interface LegacyTileBrandMarkOptions {
+    version: 1;
+    mode: 'tile';
+    sizePercent: number;
+    opacity: number;
+    density: BrandTileDensity;
+    direction: BrandTileDirection;
+    anchor?: BrandMarkAnchor;
+    marginPercent?: number;
+}
+export type BrandMarkOptions = SingleBrandMarkOptions | TileBrandMarkOptions | LegacyTileBrandMarkOptions;
+export type BrandMarkParams = BrandMarkOptions & {
+    logo: BrandLogoIdentity;
+};
+export type NormalizedBrandMarkOptions = SingleBrandMarkOptions | TileBrandMarkOptions;
+export type NormalizedBrandMarkParams = NormalizedBrandMarkOptions & {
+    logo: BrandLogoIdentity;
+};
+export interface BrandGeometry {
+    width: number;
+    height: number;
+    x: number;
+    y: number;
+    canvasWidth: number;
+    canvasHeight: number;
+}
+export interface BrandTileGeometry {
+    canvasWidth: number;
+    canvasHeight: number;
+    logoWidth: number;
+    logoHeight: number;
+    cellWidth: number;
+    cellHeight: number;
+    originX: number;
+    originY: number;
+    rotation: number;
+    logoX: number;
+    logoY: number;
+}
+export type BrandComposeResult = {
+    kind: 'image';
+    data: Uint8ClampedArray;
+    width: number;
+    height: number;
+} | {
+    kind: 'analysis';
+    skipped: true;
+    reason: 'opacity_zero' | 'transparent_logo' | 'no_change';
+    width: number;
+    height: number;
+};
+export interface LogoBackgroundResult {
+    data: Uint8ClampedArray;
+    changed: boolean;
+    reason?: 'already_transparent';
+}

package/dist/types/batch/features/brand-mark/engine.d.mts

@@ -0,0 +1,68 @@
+import type {
+  SingleBrandMarkOptions,
+  BrandMarkParams,
+  NormalizedBrandMarkParams,
+  BrandGeometry,
+  BrandTileGeometry,
+  BrandComposeResult,
+  LogoBackgroundResult,
+  BrandTileDensity,
+  BrandTileDirection,
+} from './contracts';
+export type {
+  BrandMarkAnchor,
+  BrandLogoIdentity,
+  BrandMarkOptions,
+  SingleBrandMarkOptions,
+  TileBrandMarkOptions,
+  LegacyTileBrandMarkOptions,
+  NormalizedBrandMarkOptions,
+  NormalizedBrandMarkParams,
+  BrandMarkParams,
+  BrandMarkMode,
+  BrandTileDensity,
+  BrandTileDirection,
+  BrandGeometry,
+  BrandTileGeometry,
+  BrandComposeResult,
+  LogoBackgroundResult,
+} from './contracts';
+
+export const DEFAULT_BRAND_MARK: Readonly<SingleBrandMarkOptions>;
+export const LEGACY_TILE_DENSITY: Readonly<Record<BrandTileDensity, number>>;
+export const LEGACY_TILE_ANGLE: Readonly<Record<BrandTileDirection, number>>;
+/** Before any browser preprocessing: 5MiB/static PNG/JPEG/WebP gate; actual decode remains caller-owned. */
+export function assertStaticBrandLogo(bytes: Uint8Array): void;
+export function validateBrandMark(value: unknown): NormalizedBrandMarkParams;
+/** Original upright Logo dimensions, at most 4MP; output is integer geometry. */
+export function computeBrandGeometry(
+  sourceWidth: number,
+  sourceHeight: number,
+  logoWidth: number,
+  logoHeight: number,
+  params: BrandMarkParams,
+): BrandGeometry;
+/** Center-anchored periodic field: local cell is [-cellWidth/2, -cellHeight/2]; transform is translate(origin) rotate(rotation). */
+export function computeBrandTileGeometry(
+  sourceWidth: number,
+  sourceHeight: number,
+  logoWidth: number,
+  logoHeight: number,
+  params: BrandMarkParams,
+): BrandTileGeometry;
+/** Caller resizes Logo to computeBrandGeometry dimensions first; raw upload budget is checked upstream. */
+export function composeBrandPixels(
+  source: Uint8ClampedArray,
+  width: number,
+  height: number,
+  resizedLogo: Uint8ClampedArray,
+  logoWidth: number,
+  logoHeight: number,
+  params: BrandMarkParams,
+): BrandComposeResult;
+/** Existing transparency is unchanged. Unclear backgrounds throw PROCESSING_FAILED with a reason and preserve input. */
+export function removeSolidLogoBackground(
+  rgba: Uint8ClampedArray,
+  width: number,
+  height: number,
+): LogoBackgroundResult;

package/dist/types/batch/features/export-compression/contracts.d.ts

@@ -0,0 +1,44 @@
+export type ExportFormat = 'png' | 'jpeg' | 'webp' | 'gif' | 'tga';
+export type PngCompression = 'lossless' | 'size';
+export type ExportMime = 'image/png' | 'image/jpeg' | 'image/webp' | 'image/gif' | 'image/x-tga';
+export interface EncodeOptions {
+    format: ExportFormat;
+    quality: number;
+    jpegBackground: string;
+    /** PNG-only encoder mode. Omitted keeps the pre-V1 lossless browser path. */
+    pngCompression?: PngCompression;
+}
+export interface EncodedImage {
+    blob: Blob;
+    mime: ExportMime | 'image/svg+xml';
+    width: number;
+    height: number;
+    /** The PNG export retained the source because compression did not make it smaller. */
+    preservedOriginal?: boolean;
+    previewBlob?: Blob;
+}
+export declare const MAX_IMAGE_BYTES: number;
+export declare const MAX_IMAGE_PIXELS = 24000000;
+export declare const EXPORT_MIME: Record<ExportFormat, ExportMime>;
+export type ExportPhase = 'encoding' | 'metadata';
+export type CodecRequest = {
+    id: number;
+    blob: Blob;
+    options: EncodeOptions;
+    mode?: 'codec';
+} | {
+    id: number;
+    blob: Blob;
+    settings: import('./presentation').ExportSettings;
+    mode: 'export';
+};
+export type CodecReply = {
+    id: number;
+    result: EncodedImage;
+} | {
+    id: number;
+    error: string;
+} | {
+    id: number;
+    phase: ExportPhase;
+};

package/dist/types/batch/features/export-compression/gifenc.d.ts

@@ -0,0 +1,33 @@
+declare module 'gifenc' {
+  export type GifPalette = number[][];
+  export type GifEncoder = {
+    writeFrame(
+      index: Uint8Array,
+      width: number,
+      height: number,
+      options: {
+        palette: GifPalette;
+        transparent?: boolean;
+        transparentIndex?: number;
+        colorDepth?: number;
+      },
+    ): void;
+    finish(): void;
+    bytes(): Uint8Array;
+  };
+  export function quantize(
+    rgba: Uint8Array | Uint8ClampedArray,
+    maxColors: number,
+    options?: {
+      format?: 'rgb565' | 'rgb444' | 'rgba4444';
+      clearAlpha?: boolean;
+      oneBitAlpha?: boolean | number;
+    },
+  ): GifPalette;
+  export function applyPalette(
+    rgba: Uint8Array | Uint8ClampedArray,
+    palette: GifPalette,
+    format?: 'rgb565' | 'rgb444' | 'rgba4444',
+  ): Uint8Array;
+  export function GIFEncoder(options?: { initialCapacity?: number; auto?: boolean }): GifEncoder;
+}

package/dist/types/batch/features/export-compression/plan.d.ts

@@ -0,0 +1,45 @@
+import { type Batch, type Item } from '../../model';
+import type { ExportSettings, ExportProgress, ExportReport, ExportArtifact } from './presentation';
+import type { EncodedImage } from './contracts';
+export declare const MAX_ZIP_BYTES: number;
+/** Reserve payload plus local/central UTF8 headers before adding an irreversible ZIP member. */
+export declare function reserveZipMember(reserved: number, bytes: number, name: string): number;
+export declare const DEFAULT_EXPORT_SETTINGS: ExportSettings;
+export type ExportEntry = {
+    item: Item;
+    group?: string;
+};
+export type ExportPlan = {
+    batchId: string;
+    entries: ExportEntry[];
+    excluded: ExportReport['excluded'];
+    settings: ExportSettings;
+};
+export type ExportEvent = {
+    stage: 'reading' | 'encoding' | 'metadata' | 'packing' | 'settled';
+    done: number;
+    total: number;
+    itemId?: string;
+    itemName?: string;
+    itemStatus?: 'exported' | 'excluded';
+    inputBytes?: number;
+    outputBytes?: number;
+    filename?: string;
+    preservedOriginal?: boolean;
+};
+export type ExportReadResult = {
+    blob: Blob;
+    sha256: string;
+};
+export type ExportDependencies = {
+    read: (entry: ExportEntry, signal?: AbortSignal) => Promise<ExportReadResult>;
+    render: (blob: Blob, settings: ExportSettings, signal?: AbortSignal, onPhase?: (phase: 'encoding' | 'metadata') => void) => Promise<EncodedImage>;
+};
+export declare function validateExportSettings(input: ExportSettings): ExportSettings;
+export declare function createExportPlan(batch: Batch, ids: string[], settings: ExportSettings): ExportPlan;
+export declare function checkExportAbort(signal?: AbortSignal): void;
+export declare function runExportPlan(plan: ExportPlan, deps: ExportDependencies, signal?: AbortSignal, onProgress?: (p: ExportProgress) => void, onEvent?: (event: ExportEvent) => void, onArtifact?: (artifact: ExportArtifact) => void, onReport?: (report: ExportReport) => void): Promise<{
+    blob?: Blob;
+    filename: string;
+    report: ExportReport;
+}>;

package/dist/types/batch/features/export-compression/presentation.d.ts

@@ -0,0 +1,70 @@
+/** Presentation-only contract. Encoding, source validation and cancellation belong to the caller. */
+import type { ExportFormat } from './contracts';
+export type ExportSettings = {
+    format: 'original' | ExportFormat;
+    pngCompression: 'lossless' | 'size';
+    quality: number;
+    jpegBackground: string;
+    cleanPrivacy: boolean;
+    removeTime: boolean;
+    removeAuthorComments: boolean;
+};
+export type ExportCandidate = {
+    id: string;
+    name: string;
+};
+export type ExportPreview = {
+    sourceUrl: string;
+    resultUrl: string;
+    sourceBytes: number;
+    outputBytes: number;
+    width: number;
+    height: number;
+    mime: string;
+};
+export type ExportProgress = {
+    phase: 'reading' | 'encoding' | 'metadata' | 'packing' | 'ready';
+    done: number;
+    total: number;
+    name?: string;
+};
+export type ExportArtifact = {
+    itemId: string;
+    versionId: string;
+    inputSha256: string;
+    filename: string;
+    blob: Blob;
+    bytes: number;
+    mime: string;
+    outputSha256: string;
+    preservedOriginal: boolean;
+};
+export type ExportDownload = Omit<ExportArtifact, 'blob'> & {
+    url: string;
+};
+export type ExportReport = {
+    settings?: Readonly<ExportSettings>;
+    exported: number;
+    excluded: Array<{
+        item: string;
+        reason: string;
+    }>;
+    inputBytes: number;
+    outputBytes: number;
+    items?: Array<{
+        item: string;
+        itemId?: string;
+        versionId?: string;
+        inputSha256?: string;
+        outputSha256?: string;
+        status: 'exported' | 'excluded';
+        inputBytes?: number;
+        outputBytes?: number;
+        filename?: string;
+        preservedOriginal?: boolean;
+        reason?: string;
+    }>;
+};
+export declare function formatBytes(bytes: number): string;
+export declare function byteChange(input: number, output: number): string;
+export declare const progressLabels: Record<ExportProgress['phase'], string>;

package/dist/types/batch/features/export-compression/upng.d.ts

@@ -0,0 +1,6 @@
+declare module 'upng-js' {
+  const encoder: {
+    encode(images: ArrayBuffer[], width: number, height: number, colors: number): ArrayBuffer;
+  };
+  export default encoder;
+}

package/dist/types/batch/features/final-image/resize.d.mts

@@ -0,0 +1,15 @@
+import type { ResizeParams } from '../basic-edit/contracts';
+export function resizePixels(
+  data: Uint8ClampedArray,
+  width: number,
+  height: number,
+  params: ResizeParams,
+): { data: Uint8ClampedArray; width: number; height: number; skipped?: true };
+export function resamplePixels(
+  data: Uint8ClampedArray,
+  width: number,
+  height: number,
+  targetWidth: number,
+  targetHeight: number,
+  kernel?: 'lanczos3' | 'mitchell' | 'cubic' | 'linear',
+): { data: Uint8ClampedArray; width: number; height: number };