fundus 0.5.0 → 0.7.0

package/dist/server/cli-commands.js

@@ -257,10 +257,13 @@ Example:
 export const ASSET_INGEST_HELP = `fundus asset ingest — acquire a file or Figma selection as a typed asset
 
 Usage: fundus asset ingest <file> [--type <type>] [--id <id>] [--folder <path|root>]
-                           [--manifests <a,b>] [--parameters <json>] [--from file] [--json]
+                           [--manifests <a,b>] [--parameters <json>]
+                           [--compression-x <0-100>] [--compression-y <0-100>]
+                           [--from file] [--json]
        fundus asset ingest <figma-selection-link> --from figma --type <image|slice> --id <id>
                            [--scale <1|2|3|4>] [--folder <path|root>]
-                           [--manifests <a,b>] [--parameters <json>] [--json]
+                           [--manifests <a,b>] [--parameters <json>]
+                           [--compression-x <0-100>] [--compression-y <0-100>] [--json]
 
 File ingest remains the default and behaves like an editor upload. Figma
 ingest materializes one selection as PNG through the same importer-neutral
@@ -278,6 +281,10 @@ Flags:
   --manifests <a,b>    explicit manifest membership (every name must exist)
   --parameters <json>  shallow parameter patch merged after ingest seeding
                        (see \`fundus asset set --help\`)
+  --compression-x <0-100>
+  --compression-y <0-100>
+                       percentage compression of a Slice asset's horizontal or
+                       vertical stretch region; omitted axes default to 0
   --scale <1|2|3|4>    Figma export scale; default:
                        import.figma.defaults.scale from fundus.config.ts
                        (invalid for file ingest)
@@ -287,7 +294,8 @@ Flags:
 A failed ingest leaves neither a raw file nor a record behind.
 
 Example:
-  fundus asset ingest ./exports/navigation_panel@2x.png --type slice --json
+  fundus asset ingest ./exports/navigation_panel@2x.png --type slice \\
+    --compression-x 75 --compression-y 25 --json
   fundus asset ingest 'https://www.figma.com/design/abc/UI?node-id=12-34' \\
     --from figma --type slice --id navigationPanel --scale 3 --json
 `;
@@ -332,10 +340,11 @@ Example:
 `;
 export const ASSET_SET_HELP = `fundus asset set — update an asset's parameters and/or memberships
 
-Usage: fundus asset set <id> [--parameters <json>] [--manifests <a,b>] [--json]
+Usage: fundus asset set <id> [--parameters <json>] [--manifests <a,b>]
+                             [--compression-x <0-100>] [--compression-y <0-100>] [--json]
 
-At least one of --parameters/--manifests is required. Runs the full
-autosave chain (write library → process → regenerate manifest modules).
+At least one change flag is required. Runs the full autosave chain
+(write library → process → regenerate manifest modules).
 
 Flags:
   --parameters <json>  SHALLOW MERGE at the top level onto the current
@@ -351,6 +360,12 @@ Flags:
                                                       reference
   --manifests <a,b>    REPLACES the explicit membership set (declarative,
                        idempotent); --manifests "" clears it
+  --compression-x <0-100>
+  --compression-y <0-100>
+                       set one Slice stretch-compression axis while preserving
+                       the omitted axis; setting both axes to 0 removes
+                       compression. These values override compression supplied
+                       through --parameters in the same invocation
   --json               print {"ok": true, "asset": <AssetStateDto>, "issues": […]}
   --help               this help
 
@@ -360,6 +375,7 @@ asset, a reference cycle, or an unknown manifest name. Ingest reference
 targets before pointing at them.
 
 Example:
+  fundus asset set navigationPanel --compression-x 75 --compression-y 25 --json
   fundus asset set characterIdle \\
     --parameters '{"mask": {"$asset": "characterIdleMask"}}' --json
 `;
@@ -492,6 +508,70 @@ function inferTypeForFileName(fileName) {
     }
     throw new Error(`The ".${extension}" extension is ambiguous — pass --type <${candidates.join('|')}>.`);
 }
+function parseCompressionPercentage(name, value, commandPath) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== 'string' || !/^\d+$/.test(value) || Number(value) > 100) {
+        throw new CliUsageError(`Flag "--${name}" must be an integer from 0 to 100 — run \`${commandPath} --help\`.`);
+    }
+    return Number(value);
+}
+function parseSliceCompressionFlags(flags, commandPath) {
+    const x = parseCompressionPercentage('compression-x', flags['compression-x'], commandPath);
+    const y = parseCompressionPercentage('compression-y', flags['compression-y'], commandPath);
+    if (x === undefined && y === undefined)
+        return undefined;
+    return {
+        ...(x !== undefined ? { x } : {}),
+        ...(y !== undefined ? { y } : {})
+    };
+}
+function parameterPatchRecord(parametersPatch) {
+    if (typeof parametersPatch !== 'object' ||
+        parametersPatch === null ||
+        Array.isArray(parametersPatch)) {
+        throw new Error('The parameter patch must be a JSON object, e.g. {"preset": "default"}.');
+    }
+    return parametersPatch;
+}
+function compressionFromParameters(parameters) {
+    if (typeof parameters !== 'object' || parameters === null || Array.isArray(parameters)) {
+        return { x: 0, y: 0 };
+    }
+    const compression = parameters.compression;
+    if (typeof compression !== 'object' || compression === null || Array.isArray(compression)) {
+        return { x: 0, y: 0 };
+    }
+    return compression;
+}
+/** Add the ergonomic per-axis flags to the generic top-level parameter patch. */
+function applySliceCompressionFlags(options) {
+    if (options.flags === undefined)
+        return options.parametersPatch;
+    if (options.type !== 'slice') {
+        throw new CliUsageError(`Flags "--compression-x" and "--compression-y" are only valid for Slice assets — run \`${options.commandPath} --help\`.`);
+    }
+    const patch = options.parametersPatch === undefined ? {} : parameterPatchRecord(options.parametersPatch);
+    let compression = compressionFromParameters(options.currentParameters);
+    if (Object.hasOwn(patch, 'compression')) {
+        if (patch.compression === null) {
+            compression = { x: 0, y: 0 };
+        }
+        else if (typeof patch.compression === 'object' &&
+            patch.compression !== null &&
+            !Array.isArray(patch.compression)) {
+            compression = { ...compression, ...patch.compression };
+        }
+        else {
+            throw new Error('Slice compression must be an object with x/y percentages.');
+        }
+    }
+    const nextCompression = { ...compression, ...options.flags };
+    return {
+        ...patch,
+        compression: nextCompression.x === 0 && nextCompression.y === 0 ? null : nextCompression
+    };
+}
 async function runAssetIngest(argumentList) {
     const parsed = parseArguments(argumentList, {
         ...COMMON_FLAGS,
@@ -499,6 +579,8 @@ async function runAssetIngest(argumentList) {
         id: { takesValue: true },
         manifests: { takesValue: true },
         parameters: { takesValue: true },
+        'compression-x': { takesValue: true },
+        'compression-y': { takesValue: true },
         folder: { takesValue: true },
         from: { takesValue: true },
         scale: { takesValue: true }
@@ -514,9 +596,10 @@ async function runAssetIngest(argumentList) {
     if (from === 'file' && scale !== undefined) {
         throw new CliUsageError('Flag "--scale" is only valid with `--from figma` — run `fundus asset ingest --help`.');
     }
-    const parametersPatch = typeof parsed.flags.parameters === 'string'
+    let parametersPatch = typeof parsed.flags.parameters === 'string'
         ? parseJsonFlag('parameters', parsed.flags.parameters)
         : undefined;
+    const compressionFlags = parseSliceCompressionFlags(parsed.flags, 'fundus asset ingest');
     const manifests = typeof parsed.flags.manifests === 'string'
         ? parseManifestList(parsed.flags.manifests)
         : undefined;
@@ -531,6 +614,12 @@ async function runAssetIngest(argumentList) {
         }
         const id = parsed.flags.id;
         const type = parsed.flags.type;
+        parametersPatch = applySliceCompressionFlags({
+            type,
+            flags: compressionFlags,
+            parametersPatch,
+            commandPath: 'fundus asset ingest'
+        });
         const operations = await createOperations();
         const state = await operations.importAsset({
             importer: 'figma',
@@ -561,6 +650,12 @@ async function runAssetIngest(argumentList) {
     const fileName = basename(absolutePath);
     const type = typeof parsed.flags.type === 'string' ? parsed.flags.type : inferTypeForFileName(fileName);
     const id = typeof parsed.flags.id === 'string' ? parsed.flags.id : proposeAssetId(fileName);
+    parametersPatch = applySliceCompressionFlags({
+        type,
+        flags: compressionFlags,
+        parametersPatch,
+        commandPath: 'fundus asset ingest'
+    });
     const operations = await createOperations();
     const state = await operations.ingest({
         fileName,
@@ -649,18 +744,37 @@ async function runAssetReplace(argumentList) {
     printMutationResult(`Replaced raw file for asset "${id}" with "${fileName}".`, asset, state);
 }
 async function runAssetSet(argumentList) {
-    const parsed = parseArguments(argumentList, { ...COMMON_FLAGS, parameters: { takesValue: true }, manifests: { takesValue: true } }, 'fundus asset set');
+    const parsed = parseArguments(argumentList, {
+        ...COMMON_FLAGS,
+        parameters: { takesValue: true },
+        manifests: { takesValue: true },
+        'compression-x': { takesValue: true },
+        'compression-y': { takesValue: true }
+    }, 'fundus asset set');
     const [id] = requirePositionals(parsed, ['<id>'], 'fundus asset set');
-    if (parsed.flags.parameters === undefined && parsed.flags.manifests === undefined) {
-        throw new CliUsageError('`fundus asset set` needs --parameters and/or --manifests — run `fundus asset set --help`.');
+    const compressionFlags = parseSliceCompressionFlags(parsed.flags, 'fundus asset set');
+    if (parsed.flags.parameters === undefined &&
+        parsed.flags.manifests === undefined &&
+        compressionFlags === undefined) {
+        throw new CliUsageError('`fundus asset set` needs --parameters and/or --manifests, or a compression flag — run `fundus asset set --help`.');
     }
-    const parametersPatch = typeof parsed.flags.parameters === 'string'
+    let parametersPatch = typeof parsed.flags.parameters === 'string'
         ? parseJsonFlag('parameters', parsed.flags.parameters)
         : undefined;
     const manifests = typeof parsed.flags.manifests === 'string'
         ? parseManifestList(parsed.flags.manifests)
         : undefined;
     const operations = await createOperations();
+    if (compressionFlags !== undefined) {
+        const currentAsset = assetById(await operations.state(), id);
+        parametersPatch = applySliceCompressionFlags({
+            type: currentAsset.type,
+            flags: compressionFlags,
+            parametersPatch,
+            currentParameters: currentAsset.parameters,
+            commandPath: 'fundus asset set'
+        });
+    }
     const state = await operations.setAsset(id, { parametersPatch, manifests });
     const asset = assetById(state, id);
     if (parsed.flags.json) {

package/dist/server/config-loader.d.ts

@@ -14,6 +14,8 @@ export interface ResolvedAudioPluginConfig {
     presets: Record<string, AudioPreset>;
 }
 export interface ResolvedFundusConfig {
+    /** Absolute host project directory containing fundus.config.ts. */
+    projectRoot: string;
     /** All paths absolute. */
     rawDir: string;
     proxyDir: string;

package/dist/server/config-loader.js

@@ -71,6 +71,7 @@ export function resolveConfig(projectRoot, value, registry = serverPluginsByType
         throw new Error('fundus.config: "import.figma.defaults.scale" must be 1, 2, 3, or 4.');
     }
     return {
+        projectRoot: resolve(projectRoot),
         rawDir: resolvePath(projectRoot, requiredString(value, 'rawDir')),
         proxyDir: resolvePath(projectRoot, requiredString(value, 'proxyDir')),
         library: resolvePath(projectRoot, requiredString(value, 'library')),

package/dist/server/git.d.ts

@@ -0,0 +1,9 @@
+export type GitFileChange = 'new' | 'edited';
+/** Current branch of the repository containing projectRoot; null outside Git or when detached. */
+export declare function currentGitBranch(projectRoot: string): Promise<string | null>;
+/**
+ * Raw Git file changes made since this branch diverged from the repository's
+ * default branch. Staged, unstaged, and untracked files are included so the
+ * editor updates immediately after an asset mutation, before the next commit.
+ */
+export declare function gitFileChanges(projectRoot: string): Promise<Map<string, GitFileChange>>;

package/dist/server/git.js

@@ -0,0 +1,121 @@
+import { execFile } from 'node:child_process';
+import { resolve } from 'node:path';
+import { promisify } from 'node:util';
+const execFileAsync = promisify(execFile);
+async function git(projectRoot, args) {
+    const { stdout } = await execFileAsync('git', ['-C', projectRoot, ...args], {
+        encoding: 'utf8'
+    });
+    return stdout;
+}
+/** Current branch of the repository containing projectRoot; null outside Git or when detached. */
+export async function currentGitBranch(projectRoot) {
+    try {
+        return (await git(projectRoot, ['branch', '--show-current'])).trim() || null;
+    }
+    catch {
+        return null;
+    }
+}
+async function firstExistingRef(projectRoot, refs) {
+    for (const ref of refs) {
+        try {
+            await git(projectRoot, ['rev-parse', '--verify', '--quiet', ref]);
+            return ref;
+        }
+        catch {
+            // Try the next conventional default-branch ref.
+        }
+    }
+    return null;
+}
+async function defaultBranchRef(projectRoot) {
+    try {
+        const remoteHead = (await git(projectRoot, ['symbolic-ref', '--quiet', '--short', 'refs/remotes/origin/HEAD'])).trim();
+        if (remoteHead)
+            return remoteHead;
+    }
+    catch {
+        // Repositories without an origin/HEAD fall back to conventional branch names.
+    }
+    return firstExistingRef(projectRoot, [
+        'refs/remotes/origin/main',
+        'refs/remotes/origin/master',
+        'refs/heads/main',
+        'refs/heads/master'
+    ]);
+}
+function parseDiffNames(output, root) {
+    const changes = new Map();
+    const fields = output.split('\0');
+    for (let index = 0; index < fields.length;) {
+        const status = fields[index++];
+        if (!status)
+            continue;
+        const sourcePath = fields[index++];
+        if (!sourcePath)
+            continue;
+        if (status.startsWith('R') || status.startsWith('C')) {
+            const destinationPath = fields[index++];
+            if (!destinationPath)
+                continue;
+            changes.set(resolve(root, destinationPath), status.startsWith('C') ? 'new' : 'edited');
+        }
+        else if (status === 'A') {
+            changes.set(resolve(root, sourcePath), 'new');
+        }
+        else if (status !== 'D') {
+            changes.set(resolve(root, sourcePath), 'edited');
+        }
+    }
+    return changes;
+}
+/**
+ * Raw Git file changes made since this branch diverged from the repository's
+ * default branch. Staged, unstaged, and untracked files are included so the
+ * editor updates immediately after an asset mutation, before the next commit.
+ */
+export async function gitFileChanges(projectRoot) {
+    try {
+        const prefixParts = (await git(projectRoot, ['rev-parse', '--show-prefix']))
+            .trim()
+            .split('/')
+            .filter(Boolean);
+        const root = resolve(projectRoot, ...prefixParts.map(() => '..'));
+        const defaultRef = await defaultBranchRef(projectRoot);
+        let changes = new Map();
+        if (defaultRef) {
+            try {
+                const mergeBase = (await git(projectRoot, ['merge-base', 'HEAD', defaultRef])).trim();
+                if (mergeBase) {
+                    changes = parseDiffNames(await git(projectRoot, [
+                        'diff',
+                        '--name-status',
+                        '-z',
+                        '--find-renames',
+                        mergeBase,
+                        '--'
+                    ]), root);
+                }
+            }
+            catch {
+                // An unborn or unrelated branch still has useful untracked-file state.
+            }
+        }
+        const untracked = await git(projectRoot, [
+            'ls-files',
+            '--others',
+            '--exclude-standard',
+            '--full-name',
+            '-z'
+        ]);
+        for (const path of untracked.split('\0')) {
+            if (path)
+                changes.set(resolve(root, path), 'new');
+        }
+        return changes;
+    }
+    catch {
+        return new Map();
+    }
+}

package/dist/server/library-store.d.ts

@@ -77,7 +77,7 @@ export declare class LibraryStore {
      */
     replaceRawFile(id: string, options: ReplaceRawFileOptions): Promise<Library>;
     /** CAS-protected replacement used only by a repeatable import source. */
-    replaceRawFromImportSource(id: string, bytes: Uint8Array, expected: ImportSourceExpectation, nextSource?: ImportSourceRecord): Promise<Library>;
+    replaceRawFromImportSource(id: string, bytes: Uint8Array, expected: ImportSourceExpectation, nextSource?: ImportSourceRecord, updateParameters?: (parameters: unknown) => unknown): Promise<Library>;
     /** Replace an asset's parameters (validated by the owning plugin). */
     updateParameters(id: string, parameters: unknown): Promise<Library>;
     /** Replace an asset's manifest membership (every name must exist). */

package/dist/server/library-store.js

@@ -248,7 +248,7 @@ export class LibraryStore {
         return library;
     }
     /** CAS-protected replacement used only by a repeatable import source. */
-    async replaceRawFromImportSource(id, bytes, expected, nextSource) {
+    async replaceRawFromImportSource(id, bytes, expected, nextSource, updateParameters) {
         return this.#enqueue(async () => {
             const library = await this.read();
             const record = this.#requireAsset(library, id);
@@ -272,6 +272,7 @@ export class LibraryStore {
             const backupPath = `${absolutePath}.fundus-reimport-${token}`;
             const previousHash = record.rawHash;
             const previousSource = structuredClone(record.importSource);
+            const previousParameters = structuredClone(record.parameters);
             let staged = false;
             let installed = false;
             try {
@@ -283,11 +284,14 @@ export class LibraryStore {
                 record.rawHash = sha256Hex(bytes);
                 if (nextSource)
                     record.importSource = structuredClone(nextSource);
+                if (updateParameters)
+                    record.parameters = updateParameters(record.parameters);
                 await this.write(library);
             }
             catch (cause) {
                 record.rawHash = previousHash;
                 record.importSource = previousSource;
+                record.parameters = previousParameters;
                 if (installed)
                     await unlink(absolutePath).catch(() => { });
                 if (staged)

package/dist/server/operations.js

@@ -5,7 +5,7 @@
  * and the CLI consume this class, so every
  * operation has exactly one implementation and there is no other save path.
  */
-import { join } from 'node:path';
+import { join, resolve } from 'node:path';
 import { assetIdError, allDeliveredAssetIds, canonicalizeParameters, collectAllReferences, compareCodeUnits, computeLibraryMembership, folderOfRawPath, normalizeFolderPath, parentFolderPath, portableFolderPathKey, proposeAssetId, rawFileNameOfPath, typesForFileName } from '../core/index.js';
 import { LibraryStore } from './library-store.js';
 import { generateManifestModules } from './codegen.js';
@@ -16,6 +16,8 @@ import { classifyRawDirectory, verifyStableRawFile } from './raw-reconciliation.
 import { rawSafetyIssues } from './raw-safety.js';
 import { serverImporters } from './importers.js';
 import { SourceImportError } from './importers/contract.js';
+import { validateFigmaSourceParameters } from './importers/figma.js';
+import { currentGitBranch, gitFileChanges } from './git.js';
 /**
  * The CLI's `--parameters` merge semantics (M7): a SHALLOW merge at the top
  * level onto the current parameters — a nested object value replaces the whole
@@ -42,6 +44,11 @@ export function mergeParameterPatch(currentParameters, patch) {
     }
     return merged;
 }
+function figmaSlicePixelRatio(raw, type) {
+    if (type !== 'slice' || raw.importSource?.importer !== 'figma')
+        return undefined;
+    return validateFigmaSourceParameters(raw.importSource.parameters).scale;
+}
 export class FundusOperations {
     #config;
     #registry;
@@ -310,9 +317,17 @@ export class FundusOperations {
             if (!plugin.descriptor.accepts.includes(raw.extension)) {
                 throw new SourceImportError('invalid-response', `The ${snapshot.expected.type} type does not accept ".${raw.extension}" files.`);
             }
+            // A missing input is a refresh of the saved source and deliberately
+            // preserves authored parameters. An explicit input is a reimport and
+            // synchronizes a Figma slice's pixel ratio to its new export scale.
+            const pixelRatio = snapshot.input === undefined
+                ? undefined
+                : figmaSlicePixelRatio(raw, snapshot.expected.type);
             let library;
             try {
-                library = await this.#store.replaceRawFromImportSource(id, raw.bytes, snapshot.expected, raw.importSource);
+                library = await this.#store.replaceRawFromImportSource(id, raw.bytes, snapshot.expected, raw.importSource, pixelRatio === undefined
+                    ? undefined
+                    : (parameters) => plugin.descriptor.validateParameters(mergeParameterPatch(parameters, { pixelRatio })));
             }
             catch (cause) {
                 if (cause instanceof Error && cause.message === 'stale-import') {
@@ -347,6 +362,11 @@ export class FundusOperations {
                 if (seeded !== undefined)
                     next = seeded;
             }
+            // Source scale is a default: an explicit parametersPatch below still wins.
+            const pixelRatio = figmaSlicePixelRatio(raw, options.type);
+            if (pixelRatio !== undefined) {
+                next = mergeParameterPatch(next, { pixelRatio });
+            }
             if (options.parametersPatch !== undefined) {
                 next = mergeParameterPatch(next, options.parametersPatch);
             }
@@ -642,6 +662,10 @@ export class FundusOperations {
         };
     }
     async #buildState(library, issues, classification) {
+        const [gitBranch, changedGitFiles] = await Promise.all([
+            currentGitBranch(this.#config.projectRoot),
+            gitFileChanges(this.#config.projectRoot)
+        ]);
         const referencesByAsset = collectAllReferences(library, descriptorsByType(this.#registry));
         const membershipByManifest = computeLibraryMembership(library, referencesByAsset);
         const delivered = allDeliveredAssetIds(membershipByManifest);
@@ -706,6 +730,7 @@ export class FundusOperations {
                 folder: folderOfRawPath(record.raw),
                 rawUrl: `/files/raw/${encodeRelativePathForUrl(record.raw)}?v=${record.rawHash.slice(0, 12)}`,
                 rawHash: record.rawHash,
+                gitStatus: changedGitFiles.get(resolve(this.#config.rawDir, record.raw)) ?? null,
                 importSource: record.importSource,
                 parameters: record.parameters,
                 manifests: record.manifests,
@@ -747,6 +772,7 @@ export class FundusOperations {
         }
         const rawIngestionQueue = this.#buildRawIngestionQueue(library, classification);
         return {
+            gitBranch,
             library,
             assets,
             importDefaults: { figma: { scale: this.#config.import.figma.defaults.scale } },

package/dist/server/plugins/slice.d.ts

@@ -1,7 +1,8 @@
 /**
  * Slice plugin (server part): the same sharp conversion as the image plugin,
- * never resized — insets are authored in source pixels, so the delivered proxy
- * keeps the source dimensions. The slicing data is entry-only.
+ * fixed caps keep their source-pixel size, while optional compression removes
+ * redundant pixels from the stretchable regions. The slicing data itself is
+ * entry-only.
  */
 import { type ImagePreset, type SliceParameters } from '../../core/index.js';
 import { type ServerAssetTypePlugin, type ServerPluginConfigDefinition } from './contract.js';

package/dist/server/plugins/slice.js

@@ -1,10 +1,12 @@
 /**
  * Slice plugin (server part): the same sharp conversion as the image plugin,
- * never resized — insets are authored in source pixels, so the delivered proxy
- * keeps the source dimensions. The slicing data is entry-only.
+ * fixed caps keep their source-pixel size, while optional compression removes
+ * redundant pixels from the stretchable regions. The slicing data itself is
+ * entry-only.
  */
-import { SLICE_BUILT_IN_PRESETS, defaultInsetsForSize, slicePlugin, validateImagePreset } from '../../core/index.js';
-import { processImageFile, readImageDimensions } from '../processing/image-processing.js';
+import { SLICE_BUILT_IN_PRESETS, defaultInsetsForSize, processedSliceInsets, slicePlugin, validateImagePreset } from '../../core/index.js';
+import { readImageDimensions } from '../processing/image-processing.js';
+import { processSliceImageFile } from '../processing/slice-processing.js';
 import { extensionForImageFormat } from './image.js';
 import { mergePresets } from './config.js';
 import { requireProxyField, resolveNamedPreset } from './contract.js';
@@ -51,16 +53,26 @@ export const sliceServerPlugin = {
             pixelRatio: detectPixelRatio(rawFileName)
         };
     },
-    process: (job) => processImageFile({
+    process: (job) => processSliceImageFile({
         sourcePath: job.sourcePath,
         targetPath: job.targetPath,
-        preset: job.preset
+        preset: job.preset,
+        mode: job.parameters.mode,
+        insets: job.parameters.insets,
+        overdraw: job.parameters.overdraw,
+        compression: job.parameters.compression
     }),
     readProxyInfo: (proxyPath) => readImageDimensions(proxyPath),
     buildManifestEntry: ({ parameters, src, proxy }) => {
+        const sourceWidth = requireProxyField(proxy, 'width');
+        const sourceHeight = requireProxyField(proxy, 'height');
         const slicing = {
             mode: parameters.mode,
-            insets: parameters.insets,
+            insets: processedSliceInsets({
+                ...parameters,
+                width: sourceWidth,
+                height: sourceHeight
+            }),
             pixelRatio: parameters.pixelRatio,
             // An all-zero overdraw is semantically "none" — keep the entry minimal.
             ...(hasAnySide(parameters.overdraw) ? { overdraw: parameters.overdraw } : {})
@@ -69,8 +81,8 @@ export const sliceServerPlugin = {
             kind: 'slice',
             src,
             slicing,
-            sourceWidth: requireProxyField(proxy, 'width'),
-            sourceHeight: requireProxyField(proxy, 'height')
+            sourceWidth,
+            sourceHeight
         };
     }
 };

package/dist/server/processing/slice-processing.d.ts

@@ -0,0 +1,14 @@
+import { type ImagePreset, type SliceCompression, type SliceInsets, type SliceMode } from '../../core/index.js';
+import { type ImageProcessingOutput } from './image-processing.js';
+/** The length after percentage-based compression, with one stretch pixel kept. */
+export declare function compressedStretchSize(size: number, compression: number): number;
+export declare function assertSliceCompressionDimensions(width: number, height: number): void;
+export declare function processSliceImageFile(options: {
+    sourcePath: string;
+    targetPath: string;
+    preset: ImagePreset;
+    mode: SliceMode;
+    insets: SliceInsets;
+    overdraw?: SliceInsets;
+    compression?: SliceCompression;
+}): Promise<ImageProcessingOutput>;