cursedbelt 0.0.0

package/dist/core/media/bgRemoval.js

@@ -0,0 +1,102 @@
+// Pure background removal — a breadth-first flood fill from the image edges that
+// turns the uniform, edge-connected background transparent. Lives in media-core so
+// it is identical in the Bun server (run on sharp's raw RGBA buffer), the browser,
+// and tests; it touches no DOM, no Bun, no npm dep — just a typed pixel array.
+const DEFAULT_TOLERANCE = 32;
+/** Default seeds: the four corners of the image. */
+function cornerSeeds(width, height) {
+    const x1 = width - 1;
+    const y1 = height - 1;
+    return [
+        [0, 0],
+        [x1, 0],
+        [0, y1],
+        [x1, y1],
+    ];
+}
+/**
+ * Flood-fill the background to transparent and return a fresh RGBA buffer
+ * (`width * height * 4`). The input is never mutated. A pixel is cleared when it is
+ * reachable from a seed through 4-connected neighbours that are all within
+ * `tolerance` of THAT seed's colour — so an interior region matching the background
+ * colour but walled off by the subject is preserved.
+ */
+export function floodFillBGS(pixels, opts) {
+    const { width, height, channels } = opts;
+    const tolerance = opts.tolerance ?? DEFAULT_TOLERANCE;
+    const tolSq = tolerance * tolerance;
+    const pxCount = width * height;
+    if (width <= 0 || height <= 0)
+        return new Uint8Array(0);
+    if (pixels.length < pxCount * channels) {
+        throw new Error(`floodFillBGS: buffer too small (${pixels.length} bytes for ${width}×${height}×${channels})`);
+    }
+    // Always work in RGBA so the result carries an alpha channel.
+    const out = new Uint8Array(pxCount * 4);
+    for (let i = 0; i < pxCount; i++) {
+        const s = i * channels;
+        out[i * 4] = pixels[s];
+        out[i * 4 + 1] = pixels[s + 1];
+        out[i * 4 + 2] = pixels[s + 2];
+        out[i * 4 + 3] = channels === 4 ? pixels[s + 3] : 255;
+    }
+    const cleared = new Uint8Array(pxCount); // visited+removed marker, 0/1
+    const seeds = opts.seeds ?? cornerSeeds(width, height);
+    // A flat queue of pixel indices (head pointer → O(1) dequeue). Shared across
+    // seeds: `cleared` prevents re-visiting, so one pass over all seeds is correct.
+    const queue = new Int32Array(pxCount);
+    for (const [sx, sy] of seeds) {
+        if (sx < 0 || sy < 0 || sx >= width || sy >= height)
+            continue;
+        const seedIdx = sy * width + sx;
+        if (cleared[seedIdx])
+            continue;
+        const sr = out[seedIdx * 4];
+        const sg = out[seedIdx * 4 + 1];
+        const sb = out[seedIdx * 4 + 2];
+        let head = 0;
+        let tail = 0;
+        cleared[seedIdx] = 1;
+        queue[tail++] = seedIdx;
+        while (head < tail) {
+            const idx = queue[head++];
+            out[idx * 4 + 3] = 0; // transparent
+            const x = idx % width;
+            const y = (idx - x) / width;
+            // 4-connected neighbours, each enqueued when within tolerance of THIS seed.
+            for (let n = 0, k = 0; k < 4; k++) {
+                if (k === 0) {
+                    if (x === 0)
+                        continue;
+                    n = idx - 1;
+                }
+                else if (k === 1) {
+                    if (x === width - 1)
+                        continue;
+                    n = idx + 1;
+                }
+                else if (k === 2) {
+                    if (y === 0)
+                        continue;
+                    n = idx - width;
+                }
+                else {
+                    if (y === height - 1)
+                        continue;
+                    n = idx + width;
+                }
+                if (cleared[n])
+                    continue;
+                const dr = out[n * 4] - sr;
+                const dg = out[n * 4 + 1] - sg;
+                const db = out[n * 4 + 2] - sb;
+                if (dr * dr + dg * dg + db * db <= tolSq) {
+                    cleared[n] = 1;
+                    queue[tail++] = n;
+                }
+            }
+        }
+    }
+    return out;
+}
+//# sourceMappingURL=bgRemoval.js.map

package/dist/core/media/bgRemoval.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bgRemoval.js","sourceRoot":"","sources":["../../../src/core/media/bgRemoval.ts"],"names":[],"mappings":"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"}

package/dist/core/media/format.d.ts

@@ -0,0 +1,21 @@
+import type { ImageOutputFormat } from './types';
+export declare const IMAGE_OUTPUT_FORMATS: readonly ImageOutputFormat[];
+export declare function imageFormatToMime(format: ImageOutputFormat): string;
+export declare function imageFormatToExtension(format: ImageOutputFormat): string;
+/** Best-effort MIME → output format (e.g. `image/jpeg` → `jpeg`). */
+export declare function mimeToImageFormat(mime: string | undefined): ImageOutputFormat | undefined;
+/**
+ * Clamp an image quality to a sane 1–100 integer. A missing/NaN/out-of-range value
+ * falls back to `fallback` (default 80), so a malformed spec never yields a 0-quality
+ * (blank) or >100 (sharp-throwing) encode.
+ */
+export declare function clampQuality(quality: number | undefined, fallback?: number): number;
+/**
+ * The thumbnail encode format: webp by default (small + wide support); png when
+ * transparency must survive (the source already has alpha). Keeps thumbnail policy
+ * in one tested place rather than scattered across server handlers.
+ */
+export declare function pickThumbnailFormat(opts?: {
+    hasAlpha?: boolean;
+}): ImageOutputFormat;
+//# sourceMappingURL=format.d.ts.map

package/dist/core/media/format.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"format.d.ts","sourceRoot":"","sources":["../../../src/core/media/format.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAEjD,eAAO,MAAM,oBAAoB,EAAE,SAAS,iBAAiB,EAAoC,CAAC;AAgBlG,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,iBAAiB,GAAG,MAAM,CAEnE;AAED,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,iBAAiB,GAAG,MAAM,CAExE;AAED,qEAAqE;AACrE,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,iBAAiB,GAAG,SAAS,CAQzF;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,EAAE,QAAQ,SAAK,GAAG,MAAM,CAG/E;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,CAAC,EAAE;IAAE,QAAQ,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,iBAAiB,CAEpF"}

package/dist/core/media/format.js

@@ -0,0 +1,55 @@
+// Pure format helpers — MIME/extension lookup, quality clamping, thumbnail-format
+// selection. No npm deps; shared by the server adapter, the React layer, and tests.
+export const IMAGE_OUTPUT_FORMATS = ['jpeg', 'png', 'webp', 'avif'];
+const IMAGE_MIME = {
+    jpeg: 'image/jpeg',
+    png: 'image/png',
+    webp: 'image/webp',
+    avif: 'image/avif',
+};
+const IMAGE_EXT = {
+    jpeg: 'jpg',
+    png: 'png',
+    webp: 'webp',
+    avif: 'avif',
+};
+export function imageFormatToMime(format) {
+    return IMAGE_MIME[format];
+}
+export function imageFormatToExtension(format) {
+    return IMAGE_EXT[format];
+}
+/** Best-effort MIME → output format (e.g. `image/jpeg` → `jpeg`). */
+export function mimeToImageFormat(mime) {
+    if (!mime)
+        return undefined;
+    const m = mime.toLowerCase();
+    if (m.includes('jpeg') || m.includes('jpg'))
+        return 'jpeg';
+    if (m.includes('png'))
+        return 'png';
+    if (m.includes('webp'))
+        return 'webp';
+    if (m.includes('avif'))
+        return 'avif';
+    return undefined;
+}
+/**
+ * Clamp an image quality to a sane 1–100 integer. A missing/NaN/out-of-range value
+ * falls back to `fallback` (default 80), so a malformed spec never yields a 0-quality
+ * (blank) or >100 (sharp-throwing) encode.
+ */
+export function clampQuality(quality, fallback = 80) {
+    if (quality == null || !Number.isFinite(quality))
+        return fallback;
+    return Math.min(100, Math.max(1, Math.round(quality)));
+}
+/**
+ * The thumbnail encode format: webp by default (small + wide support); png when
+ * transparency must survive (the source already has alpha). Keeps thumbnail policy
+ * in one tested place rather than scattered across server handlers.
+ */
+export function pickThumbnailFormat(opts) {
+    return opts?.hasAlpha ? 'png' : 'webp';
+}
+//# sourceMappingURL=format.js.map

package/dist/core/media/format.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"format.js","sourceRoot":"","sources":["../../../src/core/media/format.ts"],"names":[],"mappings":"AAAA,kFAAkF;AAClF,oFAAoF;AAIpF,MAAM,CAAC,MAAM,oBAAoB,GAAiC,CAAC,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;AAElG,MAAM,UAAU,GAAsC;IACpD,IAAI,EAAE,YAAY;IAClB,GAAG,EAAE,WAAW;IAChB,IAAI,EAAE,YAAY;IAClB,IAAI,EAAE,YAAY;CACnB,CAAC;AAEF,MAAM,SAAS,GAAsC;IACnD,IAAI,EAAE,KAAK;IACX,GAAG,EAAE,KAAK;IACV,IAAI,EAAE,MAAM;IACZ,IAAI,EAAE,MAAM;CACb,CAAC;AAEF,MAAM,UAAU,iBAAiB,CAAC,MAAyB;IACzD,OAAO,UAAU,CAAC,MAAM,CAAC,CAAC;AAC5B,CAAC;AAED,MAAM,UAAU,sBAAsB,CAAC,MAAyB;IAC9D,OAAO,SAAS,CAAC,MAAM,CAAC,CAAC;AAC3B,CAAC;AAED,qEAAqE;AACrE,MAAM,UAAU,iBAAiB,CAAC,IAAwB;IACxD,IAAI,CAAC,IAAI;QAAE,OAAO,SAAS,CAAC;IAC5B,MAAM,CAAC,GAAG,IAAI,CAAC,WAAW,EAAE,CAAC;IAC7B,IAAI,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC;QAAE,OAAO,MAAM,CAAC;IAC3D,IAAI,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC;QAAE,OAAO,KAAK,CAAC;IACpC,IAAI,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC;QAAE,OAAO,MAAM,CAAC;IACtC,IAAI,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC;QAAE,OAAO,MAAM,CAAC;IACtC,OAAO,SAAS,CAAC;AACnB,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,YAAY,CAAC,OAA2B,EAAE,QAAQ,GAAG,EAAE;IACrE,IAAI,OAAO,IAAI,IAAI,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,OAAO,CAAC;QAAE,OAAO,QAAQ,CAAC;IAClE,OAAO,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;AACzD,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,mBAAmB,CAAC,IAA6B;IAC/D,OAAO,IAAI,EAAE,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC;AACzC,CAAC"}

package/dist/core/media/index.d.ts

@@ -0,0 +1,8 @@
+export { type FloodFillBGOptions, floodFillBGS } from './bgRemoval';
+export { clampQuality, IMAGE_OUTPUT_FORMATS, imageFormatToExtension, imageFormatToMime, mimeToImageFormat, pickThumbnailFormat, } from './format';
+export { isAudioItem, isImageItem, isVideoItem, mediaItemAspect, mediaItemDimensions, } from './mediaItem';
+export { closeMask, createRegionSegmenter, DEFAULT_CLOSE_RADIUS, DEFAULT_TOLERANCE, dilateMask, downscaleRgba, erodeMask, fitWorkingSize, type ImageSegmenter, type SegmentOptions, type SegmentPrompt, type SegmentSource, sensitivityToTolerance, upscaleMask, } from './segment';
+export { type ClampTrimOptions, clampTrimRange, formatTimecode, type TrimRange, trimDurationSeconds, } from './trim';
+export type { ImageOperation, ImageOutputFormat, ImagePipelineSpec, MediaItem, MediaKind, VideoFormat, VideoProgressEvent, VideoQuality, VideoTrimSpec, } from './types';
+export { assertValidImagePipelineSpec, assertValidVideoTrimSpec, type ValidationResult, validateImagePipelineSpec, validateVideoTrimSpec, } from './validate';
+//# sourceMappingURL=index.d.ts.map

package/dist/core/media/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/media/index.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,KAAK,kBAAkB,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AACpE,OAAO,EACL,YAAY,EACZ,oBAAoB,EACpB,sBAAsB,EACtB,iBAAiB,EACjB,iBAAiB,EACjB,mBAAmB,GACpB,MAAM,UAAU,CAAC;AAClB,OAAO,EACL,WAAW,EACX,WAAW,EACX,WAAW,EACX,eAAe,EACf,mBAAmB,GACpB,MAAM,aAAa,CAAC;AACrB,OAAO,EACL,SAAS,EACT,qBAAqB,EACrB,oBAAoB,EACpB,iBAAiB,EACjB,UAAU,EACV,aAAa,EACb,SAAS,EACT,cAAc,EACd,KAAK,cAAc,EACnB,KAAK,cAAc,EACnB,KAAK,aAAa,EAClB,KAAK,aAAa,EAClB,sBAAsB,EACtB,WAAW,GACZ,MAAM,WAAW,CAAC;AACnB,OAAO,EACL,KAAK,gBAAgB,EACrB,cAAc,EACd,cAAc,EACd,KAAK,SAAS,EACd,mBAAmB,GACpB,MAAM,QAAQ,CAAC;AAChB,YAAY,EACV,cAAc,EACd,iBAAiB,EACjB,iBAAiB,EACjB,SAAS,EACT,SAAS,EACT,WAAW,EACX,kBAAkB,EAClB,YAAY,EACZ,aAAa,GACd,MAAM,SAAS,CAAC;AACjB,OAAO,EACL,4BAA4B,EAC5B,wBAAwB,EACxB,KAAK,gBAAgB,EACrB,yBAAyB,EACzB,qBAAqB,GACtB,MAAM,YAAY,CAAC"}

package/dist/core/media/index.js

@@ -0,0 +1,11 @@
+// cursedbelt/media-core — pure, dependency-free media contract + utilities shared by
+// the Bun server adapter (`cursedbelt/server/media`), the React components
+// (`cursedbelt/react/media`), and any consuming app/test. No React, no Bun, no npm
+// dep — the same module loads identically everywhere.
+export { floodFillBGS } from './bgRemoval';
+export { clampQuality, IMAGE_OUTPUT_FORMATS, imageFormatToExtension, imageFormatToMime, mimeToImageFormat, pickThumbnailFormat, } from './format';
+export { isAudioItem, isImageItem, isVideoItem, mediaItemAspect, mediaItemDimensions, } from './mediaItem';
+export { closeMask, createRegionSegmenter, DEFAULT_CLOSE_RADIUS, DEFAULT_TOLERANCE, dilateMask, downscaleRgba, erodeMask, fitWorkingSize, sensitivityToTolerance, upscaleMask, } from './segment';
+export { clampTrimRange, formatTimecode, trimDurationSeconds, } from './trim';
+export { assertValidImagePipelineSpec, assertValidVideoTrimSpec, validateImagePipelineSpec, validateVideoTrimSpec, } from './validate';
+//# sourceMappingURL=index.js.map

package/dist/core/media/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/core/media/index.ts"],"names":[],"mappings":"AAAA,qFAAqF;AACrF,2EAA2E;AAC3E,mFAAmF;AACnF,sDAAsD;AAEtD,OAAO,EAA2B,YAAY,EAAE,MAAM,aAAa,CAAC;AACpE,OAAO,EACL,YAAY,EACZ,oBAAoB,EACpB,sBAAsB,EACtB,iBAAiB,EACjB,iBAAiB,EACjB,mBAAmB,GACpB,MAAM,UAAU,CAAC;AAClB,OAAO,EACL,WAAW,EACX,WAAW,EACX,WAAW,EACX,eAAe,EACf,mBAAmB,GACpB,MAAM,aAAa,CAAC;AACrB,OAAO,EACL,SAAS,EACT,qBAAqB,EACrB,oBAAoB,EACpB,iBAAiB,EACjB,UAAU,EACV,aAAa,EACb,SAAS,EACT,cAAc,EAKd,sBAAsB,EACtB,WAAW,GACZ,MAAM,WAAW,CAAC;AACnB,OAAO,EAEL,cAAc,EACd,cAAc,EAEd,mBAAmB,GACpB,MAAM,QAAQ,CAAC;AAYhB,OAAO,EACL,4BAA4B,EAC5B,wBAAwB,EAExB,yBAAyB,EACzB,qBAAqB,GACtB,MAAM,YAAY,CAAC"}

package/dist/core/media/mediaItem.d.ts

@@ -0,0 +1,16 @@
+import type { MediaItem } from './types';
+export declare const isImageItem: (item: MediaItem) => boolean;
+export declare const isVideoItem: (item: MediaItem) => boolean;
+export declare const isAudioItem: (item: MediaItem) => boolean;
+/**
+ * Resolve renderable dimensions for an item. Real `width`/`height` win; otherwise a
+ * per-kind default (4:3 image, 16:9 video, 1:1 audio) keeps the justified/masonry
+ * layout from collapsing a dimensionless item to zero height.
+ */
+export declare function mediaItemDimensions(item: MediaItem): {
+    width: number;
+    height: number;
+};
+/** width / height (clamped to a sane range), falling back to `fallback` (default 1). */
+export declare function mediaItemAspect(item: MediaItem, fallback?: number): number;
+//# sourceMappingURL=mediaItem.d.ts.map

package/dist/core/media/mediaItem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mediaItem.d.ts","sourceRoot":"","sources":["../../../src/core/media/mediaItem.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAEzC,eAAO,MAAM,WAAW,GAAI,MAAM,SAAS,KAAG,OAAgC,CAAC;AAC/E,eAAO,MAAM,WAAW,GAAI,MAAM,SAAS,KAAG,OAAgC,CAAC;AAC/E,eAAO,MAAM,WAAW,GAAI,MAAM,SAAS,KAAG,OAAgC,CAAC;AAS/E;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,SAAS,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAKtF;AAED,wFAAwF;AACxF,wBAAgB,eAAe,CAAC,IAAI,EAAE,SAAS,EAAE,QAAQ,SAAI,GAAG,MAAM,CAKrE"}

package/dist/core/media/mediaItem.js

@@ -0,0 +1,35 @@
+// Pure MediaItem helpers — kind predicates + dimension/aspect resolution. The React
+// catalogue maps items to layout photos through these, so the "what size is this
+// thumbnail" logic is tested here, not buried in a component.
+export const isImageItem = (item) => item.type === 'image';
+export const isVideoItem = (item) => item.type === 'video';
+export const isAudioItem = (item) => item.type === 'audio';
+/** Default cell shape when an item carries no intrinsic dimensions. */
+const FALLBACK_DIMS = {
+    image: { width: 4, height: 3 },
+    video: { width: 16, height: 9 },
+    audio: { width: 1, height: 1 },
+};
+/**
+ * Resolve renderable dimensions for an item. Real `width`/`height` win; otherwise a
+ * per-kind default (4:3 image, 16:9 video, 1:1 audio) keeps the justified/masonry
+ * layout from collapsing a dimensionless item to zero height.
+ */
+export function mediaItemDimensions(item) {
+    if (isPositive(item.width) && isPositive(item.height)) {
+        return { width: item.width, height: item.height };
+    }
+    return FALLBACK_DIMS[item.type];
+}
+/** width / height (clamped to a sane range), falling back to `fallback` (default 1). */
+export function mediaItemAspect(item, fallback = 1) {
+    const { width, height } = mediaItemDimensions(item);
+    if (!isPositive(width) || !isPositive(height))
+        return fallback;
+    const ratio = width / height;
+    return Number.isFinite(ratio) && ratio > 0 ? ratio : fallback;
+}
+function isPositive(n) {
+    return typeof n === 'number' && Number.isFinite(n) && n > 0;
+}
+//# sourceMappingURL=mediaItem.js.map

package/dist/core/media/mediaItem.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mediaItem.js","sourceRoot":"","sources":["../../../src/core/media/mediaItem.ts"],"names":[],"mappings":"AAAA,oFAAoF;AACpF,iFAAiF;AACjF,8DAA8D;AAI9D,MAAM,CAAC,MAAM,WAAW,GAAG,CAAC,IAAe,EAAW,EAAE,CAAC,IAAI,CAAC,IAAI,KAAK,OAAO,CAAC;AAC/E,MAAM,CAAC,MAAM,WAAW,GAAG,CAAC,IAAe,EAAW,EAAE,CAAC,IAAI,CAAC,IAAI,KAAK,OAAO,CAAC;AAC/E,MAAM,CAAC,MAAM,WAAW,GAAG,CAAC,IAAe,EAAW,EAAE,CAAC,IAAI,CAAC,IAAI,KAAK,OAAO,CAAC;AAE/E,uEAAuE;AACvE,MAAM,aAAa,GAAiE;IAClF,KAAK,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE;IAC9B,KAAK,EAAE,EAAE,KAAK,EAAE,EAAE,EAAE,MAAM,EAAE,CAAC,EAAE;IAC/B,KAAK,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE;CAC/B,CAAC;AAEF;;;;GAIG;AACH,MAAM,UAAU,mBAAmB,CAAC,IAAe;IACjD,IAAI,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,UAAU,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC;QACtD,OAAO,EAAE,KAAK,EAAE,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,CAAC,MAAM,EAAE,CAAC;IACpD,CAAC;IACD,OAAO,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAClC,CAAC;AAED,wFAAwF;AACxF,MAAM,UAAU,eAAe,CAAC,IAAe,EAAE,QAAQ,GAAG,CAAC;IAC3D,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,mBAAmB,CAAC,IAAI,CAAC,CAAC;IACpD,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC;QAAE,OAAO,QAAQ,CAAC;IAC/D,MAAM,KAAK,GAAG,KAAK,GAAG,MAAM,CAAC;IAC7B,OAAO,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,QAAQ,CAAC;AAChE,CAAC;AAED,SAAS,UAAU,CAAC,CAAqB;IACvC,OAAO,OAAO,CAAC,KAAK,QAAQ,IAAI,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AAC9D,CAAC"}

package/dist/core/media/segment.d.ts

@@ -0,0 +1,80 @@
+/** A source image as raw RGBA pixels at its working dimensions. */
+export interface SegmentSource {
+    /** RGBA pixels, length `width * height * 4`. */
+    readonly data: Uint8ClampedArray;
+    readonly width: number;
+    readonly height: number;
+}
+/**
+ * What to select. `point` = magic-wand from a clicked pixel; `box` = the dominant object
+ * inside a dragged rectangle. Coordinates are in the SOURCE pixel space passed in `source`
+ * (the painter downscales both the image and the prompt together for large images).
+ */
+export type SegmentPrompt = {
+    readonly type: 'point';
+    readonly x: number;
+    readonly y: number;
+} | {
+    readonly type: 'box';
+    readonly x0: number;
+    readonly y0: number;
+    readonly x1: number;
+    readonly y1: number;
+};
+export interface SegmentOptions {
+    /**
+     * Colour-distance tolerance (RGB euclidean, 0–441) for region growth: a neighbour joins
+     * the region when it is within this distance of the seed colour. Higher = looser (selects
+     * more, leaks across gradients sooner). Default {@link DEFAULT_TOLERANCE}. The painter maps
+     * a 0–100 "sensitivity" slider onto this via {@link sensitivityToTolerance}.
+     */
+    readonly tolerance?: number;
+    /**
+     * Morphological close radius (px) applied after growth to fill speckle + small holes and
+     * smooth the edge. 0 disables it. Default {@link DEFAULT_CLOSE_RADIUS}.
+     */
+    readonly closeRadius?: number;
+}
+/**
+ * A promptable image segmenter: `(source, prompt) → binary alpha plane (0/255)` at the
+ * source's dimensions, white where selected. `segment` may be sync (the pure region grower)
+ * or async (a model-backed engine); the painter always awaits it. `dispose` releases any
+ * held resources (e.g. an ONNX session) and is optional.
+ */
+export interface ImageSegmenter {
+    /** Stable identifier for diagnostics / telemetry (e.g. `'region-grow'`, `'mobile-sam'`). */
+    readonly id: string;
+    segment(source: SegmentSource, prompt: SegmentPrompt, options?: SegmentOptions): Uint8ClampedArray | Promise<Uint8ClampedArray>;
+    dispose?(): void;
+}
+export declare const DEFAULT_TOLERANCE = 28;
+export declare const DEFAULT_CLOSE_RADIUS = 2;
+/** Map a 0–100 "sensitivity" slider to a growth tolerance. 0 → tight (exact colour), 100 →
+ *  loose. A gentle quadratic keeps the low end fine-grained where most clicks land. */
+export declare function sensitivityToTolerance(sensitivity: number): number;
+/** 4-connected binary dilate (grow by 1px). */
+export declare function dilateMask(mask: Uint8ClampedArray, width: number, height: number): Uint8ClampedArray;
+/** 4-connected binary erode (shrink by 1px). */
+export declare function erodeMask(mask: Uint8ClampedArray, width: number, height: number): Uint8ClampedArray;
+/** Morphological close (dilate×r then erode×r): fills holes/gaps ≤ ~2·radius and smooths
+ *  the edge without changing the overall area. */
+export declare function closeMask(mask: Uint8ClampedArray, width: number, height: number, radius: number): Uint8ClampedArray;
+/** Working size that fits within `maxPixels` while preserving aspect (never upsizes). */
+export declare function fitWorkingSize(width: number, height: number, maxPixels: number): {
+    width: number;
+    height: number;
+    scale: number;
+};
+/** Area-average downscale of an RGBA buffer (stable colours → cleaner growth than nearest). */
+export declare function downscaleRgba(data: Uint8ClampedArray, sw: number, sh: number, dw: number, dh: number): Uint8ClampedArray;
+/** Nearest-neighbour upscale of a 0/255 mask back to the source's natural dimensions. */
+export declare function upscaleMask(mask: Uint8ClampedArray, sw: number, sh: number, dw: number, dh: number): Uint8ClampedArray;
+/**
+ * The default, pure region-growing segmenter — no model, no download, instant + offline.
+ * `point` grows a magic-wand selection from the clicked pixel; `box` selects the dominant
+ * object inside the rectangle by growing from a spread of interior seeds, clipped to the
+ * box so it can't leak into the surrounding scene. Always returns a binary alpha plane at
+ * the source dimensions; the painter lands it as an editable region for accept/refine.
+ */
+export declare function createRegionSegmenter(defaults?: SegmentOptions): ImageSegmenter;
+//# sourceMappingURL=segment.d.ts.map

package/dist/core/media/segment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"segment.d.ts","sourceRoot":"","sources":["../../../src/core/media/segment.ts"],"names":[],"mappings":"AAcA,mEAAmE;AACnE,MAAM,WAAW,aAAa;IAC5B,gDAAgD;IAChD,QAAQ,CAAC,IAAI,EAAE,iBAAiB,CAAC;IACjC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED;;;;GAIG;AACH,MAAM,MAAM,aAAa,GACrB;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAA;CAAE,GAClE;IACE,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAC;IACrB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;CACrB,CAAC;AAEN,MAAM,WAAW,cAAc;IAC7B;;;;;OAKG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B;;;OAGG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;CAC/B;AAED;;;;;GAKG;AACH,MAAM,WAAW,cAAc;IAC7B,4FAA4F;IAC5F,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,OAAO,CACL,MAAM,EAAE,aAAa,EACrB,MAAM,EAAE,aAAa,EACrB,OAAO,CAAC,EAAE,cAAc,GACvB,iBAAiB,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAAC;IAClD,OAAO,CAAC,IAAI,IAAI,CAAC;CAClB;AAED,eAAO,MAAM,iBAAiB,KAAK,CAAC;AACpC,eAAO,MAAM,oBAAoB,IAAI,CAAC;AAEtC;uFACuF;AACvF,wBAAgB,sBAAsB,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,CAGlE;AAqFD,+CAA+C;AAC/C,wBAAgB,UAAU,CACxB,IAAI,EAAE,iBAAiB,EACvB,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,GACb,iBAAiB,CAiBnB;AAED,gDAAgD;AAChD,wBAAgB,SAAS,CACvB,IAAI,EAAE,iBAAiB,EACvB,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,GACb,iBAAiB,CAiBnB;AAED;kDACkD;AAClD,wBAAgB,SAAS,CACvB,IAAI,EAAE,iBAAiB,EACvB,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,GACb,iBAAiB,CAKnB;AAID,yFAAyF;AACzF,wBAAgB,cAAc,CAC5B,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,GAChB;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAYlD;AAED,+FAA+F;AAC/F,wBAAgB,aAAa,CAC3B,IAAI,EAAE,iBAAiB,EACvB,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,GACT,iBAAiB,CAgCnB;AAED,yFAAyF;AACzF,wBAAgB,WAAW,CACzB,IAAI,EAAE,iBAAiB,EACvB,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,GACT,iBAAiB,CAWnB;AAMD;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CAAC,QAAQ,GAAE,cAAmB,GAAG,cAAc,CAkCnF"}

package/dist/core/media/segment.js

@@ -0,0 +1,248 @@
+// Pure, dependency-free promptable image segmentation — the engine behind the
+// <MaskPainter>'s "auto-select" (Stage I, task 52). Given a source image's RGBA pixels
+// and a point/box prompt, it produces a BINARY alpha plane (0/255) marking the selected
+// object, which the painter lands as an EDITABLE mask region (never a final answer — the
+// owner refines or discards it). It is the object-select counterpart to {@link floodFillBGS}
+// (which clears an edge-connected BACKGROUND): both grow regions by colour similarity, but
+// this one selects a FOREGROUND object from a user prompt and returns a mask, not an alpha.
+//
+// No DOM, no Bun, no npm dep — just typed pixel arrays — so it runs identically in the
+// browser, on a server (sharp's raw RGBA), and in unit tests, and is fully testable with no
+// canvas. The {@link ImageSegmenter} interface is the seam: the default region grower needs
+// no model download (instant, offline), and a heavier engine (SAM2-tiny / MobileSAM via
+// onnxruntime-web) can implement the SAME interface and drop in unchanged.
+export const DEFAULT_TOLERANCE = 28;
+export const DEFAULT_CLOSE_RADIUS = 2;
+/** Map a 0–100 "sensitivity" slider to a growth tolerance. 0 → tight (exact colour), 100 →
+ *  loose. A gentle quadratic keeps the low end fine-grained where most clicks land. */
+export function sensitivityToTolerance(sensitivity) {
+    const s = Math.max(0, Math.min(100, sensitivity)) / 100;
+    return Math.round(6 + s * s * 150); // ~6 (exact) … 156 (very loose)
+}
+// ── Region growth (the pure CV core) ───────────────────────────────────────────
+/** Flood a single connected region from `seed`, including 4-connected neighbours within
+ *  `tolSq` of the SEED colour and inside the inclusive `bounds`. Returns a 0/255 mask. */
+function floodFrom(data, width, seed, tolSq, bounds, out, visited, queue) {
+    const [bx0, by0, bx1, by1] = bounds;
+    const [sx, sy] = seed;
+    if (sx < bx0 || sy < by0 || sx > bx1 || sy > by1)
+        return;
+    const seedIdx = sy * width + sx;
+    if (visited[seedIdx])
+        return;
+    const sr = data[seedIdx * 4];
+    const sg = data[seedIdx * 4 + 1];
+    const sb = data[seedIdx * 4 + 2];
+    let head = 0;
+    let tail = 0;
+    visited[seedIdx] = 1;
+    queue[tail++] = seedIdx;
+    while (head < tail) {
+        const idx = queue[head++];
+        out[idx] = 255;
+        const x = idx % width;
+        const y = (idx - x) / width;
+        for (let k = 0; k < 4; k++) {
+            let n;
+            if (k === 0) {
+                if (x <= bx0)
+                    continue;
+                n = idx - 1;
+            }
+            else if (k === 1) {
+                if (x >= bx1)
+                    continue;
+                n = idx + 1;
+            }
+            else if (k === 2) {
+                if (y <= by0)
+                    continue;
+                n = idx - width;
+            }
+            else {
+                if (y >= by1)
+                    continue;
+                n = idx + width;
+            }
+            if (visited[n])
+                continue;
+            const dr = data[n * 4] - sr;
+            const dg = data[n * 4 + 1] - sg;
+            const db = data[n * 4 + 2] - sb;
+            if (dr * dr + dg * dg + db * db <= tolSq) {
+                visited[n] = 1;
+                queue[tail++] = n;
+            }
+        }
+    }
+}
+/** Grow + union a region from one or more seeds (each its own colour-relative flood), then
+ *  morphologically close it. The shared building block for both prompt types. */
+function growRegion(source, seeds, bounds, tolerance, closeRadius) {
+    const { data, width, height } = source;
+    const px = width * height;
+    const mask = new Uint8ClampedArray(px);
+    const queue = new Int32Array(px);
+    const tolSq = tolerance * tolerance;
+    // Independent floods (fresh `visited` each) unioned into `mask`, so a later seed isn't
+    // starved by an earlier seed's rejected pixels — important for multi-tone box selects.
+    for (const seed of seeds) {
+        floodFrom(data, width, seed, tolSq, bounds, mask, new Uint8Array(px), queue);
+    }
+    return closeRadius > 0 ? closeMask(mask, width, height, closeRadius) : mask;
+}
+// ── Morphology ──────────────────────────────────────────────────────────────────
+/** 4-connected binary dilate (grow by 1px). */
+export function dilateMask(mask, width, height) {
+    const out = new Uint8ClampedArray(mask.length);
+    for (let y = 0; y < height; y++) {
+        for (let x = 0; x < width; x++) {
+            const i = y * width + x;
+            if (mask[i] ||
+                (x > 0 && mask[i - 1]) ||
+                (x < width - 1 && mask[i + 1]) ||
+                (y > 0 && mask[i - width]) ||
+                (y < height - 1 && mask[i + width])) {
+                out[i] = 255;
+            }
+        }
+    }
+    return out;
+}
+/** 4-connected binary erode (shrink by 1px). */
+export function erodeMask(mask, width, height) {
+    const out = new Uint8ClampedArray(mask.length);
+    for (let y = 0; y < height; y++) {
+        for (let x = 0; x < width; x++) {
+            const i = y * width + x;
+            if (mask[i] &&
+                (x === 0 || mask[i - 1]) &&
+                (x === width - 1 || mask[i + 1]) &&
+                (y === 0 || mask[i - width]) &&
+                (y === height - 1 || mask[i + width])) {
+                out[i] = 255;
+            }
+        }
+    }
+    return out;
+}
+/** Morphological close (dilate×r then erode×r): fills holes/gaps ≤ ~2·radius and smooths
+ *  the edge without changing the overall area. */
+export function closeMask(mask, width, height, radius) {
+    let m = mask;
+    for (let i = 0; i < radius; i++)
+        m = dilateMask(m, width, height);
+    for (let i = 0; i < radius; i++)
+        m = erodeMask(m, width, height);
+    return m;
+}
+// ── Resolution helpers (the painter caps work to keep auto-select ~instant) ──────
+/** Working size that fits within `maxPixels` while preserving aspect (never upsizes). */
+export function fitWorkingSize(width, height, maxPixels) {
+    if (width <= 0 || height <= 0)
+        return { width: 0, height: 0, scale: 1 };
+    const total = width * height;
+    if (total <= maxPixels)
+        return { width, height, scale: 1 };
+    const scale = Math.sqrt(maxPixels / total);
+    // Floor (not round) the dims so the working area is GUARANTEED ≤ maxPixels
+    // (floor(w·s)·floor(h·s) ≤ w·s·h·s = maxPixels), bounding auto-select latency.
+    return {
+        width: Math.max(1, Math.floor(width * scale)),
+        height: Math.max(1, Math.floor(height * scale)),
+        scale,
+    };
+}
+/** Area-average downscale of an RGBA buffer (stable colours → cleaner growth than nearest). */
+export function downscaleRgba(data, sw, sh, dw, dh) {
+    if (dw === sw && dh === sh)
+        return data;
+    const out = new Uint8ClampedArray(dw * dh * 4);
+    for (let y = 0; y < dh; y++) {
+        const sy0 = Math.floor((y * sh) / dh);
+        const sy1 = Math.max(sy0 + 1, Math.floor(((y + 1) * sh) / dh));
+        for (let x = 0; x < dw; x++) {
+            const sx0 = Math.floor((x * sw) / dw);
+            const sx1 = Math.max(sx0 + 1, Math.floor(((x + 1) * sw) / dw));
+            let r = 0;
+            let g = 0;
+            let b = 0;
+            let a = 0;
+            let count = 0;
+            for (let yy = sy0; yy < sy1 && yy < sh; yy++) {
+                for (let xx = sx0; xx < sx1 && xx < sw; xx++) {
+                    const s = (yy * sw + xx) << 2;
+                    r += data[s];
+                    g += data[s + 1];
+                    b += data[s + 2];
+                    a += data[s + 3];
+                    count++;
+                }
+            }
+            const o = (y * dw + x) << 2;
+            out[o] = count ? r / count : 0;
+            out[o + 1] = count ? g / count : 0;
+            out[o + 2] = count ? b / count : 0;
+            out[o + 3] = count ? a / count : 0;
+        }
+    }
+    return out;
+}
+/** Nearest-neighbour upscale of a 0/255 mask back to the source's natural dimensions. */
+export function upscaleMask(mask, sw, sh, dw, dh) {
+    if (sw === dw && sh === dh)
+        return mask;
+    const out = new Uint8ClampedArray(dw * dh);
+    for (let y = 0; y < dh; y++) {
+        const sy = Math.min(sh - 1, Math.floor((y * sh) / dh));
+        for (let x = 0; x < dw; x++) {
+            const sx = Math.min(sw - 1, Math.floor((x * sw) / dw));
+            out[y * dw + x] = mask[sy * sw + sx];
+        }
+    }
+    return out;
+}
+// ── The default engine ────────────────────────────────────────────────────────
+const clampInt = (v, lo, hi) => Math.max(lo, Math.min(hi, Math.round(v)));
+/**
+ * The default, pure region-growing segmenter — no model, no download, instant + offline.
+ * `point` grows a magic-wand selection from the clicked pixel; `box` selects the dominant
+ * object inside the rectangle by growing from a spread of interior seeds, clipped to the
+ * box so it can't leak into the surrounding scene. Always returns a binary alpha plane at
+ * the source dimensions; the painter lands it as an editable region for accept/refine.
+ */
+export function createRegionSegmenter(defaults = {}) {
+    return {
+        id: 'region-grow',
+        segment(source, prompt, options) {
+            const { width, height } = source;
+            if (width <= 0 || height <= 0)
+                return new Uint8ClampedArray(0);
+            const tolerance = options?.tolerance ?? defaults.tolerance ?? DEFAULT_TOLERANCE;
+            const closeRadius = options?.closeRadius ?? defaults.closeRadius ?? DEFAULT_CLOSE_RADIUS;
+            if (prompt.type === 'point') {
+                const seed = [
+                    clampInt(prompt.x, 0, width - 1),
+                    clampInt(prompt.y, 0, height - 1),
+                ];
+                return growRegion(source, [seed], [0, 0, width - 1, height - 1], tolerance, closeRadius);
+            }
+            // box — normalise + clamp, then seed a 3×3 grid of interior points and grow within bounds.
+            const bx0 = clampInt(Math.min(prompt.x0, prompt.x1), 0, width - 1);
+            const by0 = clampInt(Math.min(prompt.y0, prompt.y1), 0, height - 1);
+            const bx1 = clampInt(Math.max(prompt.x0, prompt.x1), 0, width - 1);
+            const by1 = clampInt(Math.max(prompt.y0, prompt.y1), 0, height - 1);
+            const seeds = [];
+            for (let r = 1; r <= 3; r++) {
+                for (let c = 1; c <= 3; c++) {
+                    seeds.push([
+                        clampInt(bx0 + ((bx1 - bx0) * c) / 4, bx0, bx1),
+                        clampInt(by0 + ((by1 - by0) * r) / 4, by0, by1),
+                    ]);
+                }
+            }
+            return growRegion(source, seeds, [bx0, by0, bx1, by1], tolerance, closeRadius);
+        },
+    };
+}
+//# sourceMappingURL=segment.js.map