feat(slicer): unified Cloud/local/standard presets + harden 3MF profile path

UNIFIED PRESET LISTING (the main feature)

  The initial slicer integration only saw DB-backed local imports — users
  without imported profiles got an empty Slice modal even when their
  Bambu Cloud account or the slicer sidecar carried perfectly usable
  presets. The Slice modal now pulls from three tiers in priority order:

    - cloud:    user's own Bambu Cloud presets, fetched live.
    - local:    DB-backed imports.
    - standard: slicer-bundled stock profiles via the sidecar's new
                GET /profiles/bundled endpoint.

  Listing endpoint: GET /api/v1/slicer/presets

    - Name-based dedup, cloud > local > standard, within-tier order
      preserved exactly. A preset that exists in multiple tiers only
      renders in the highest-priority one.
    - cloud_status (ok / not_authenticated / expired / unreachable)
      drives a precise modal banner instead of an unexplained empty
      list.
    - Cloud branch: per-user cache, 5 min TTL, key
      (user_id, sha256(token)[:16]) so logout/login or token rotation
      auto-invalidates without callback wiring from the cloud-auth
      routes.
    - Bundled branch: global cache, 1 h TTL.
    - Bundled URL respects preferred_slicer (bambu_studio vs orcaslicer)
      so BambuStudio installs see the bambu sidecar's bundled list, not
      OrcaSlicer's.

  Slicing endpoint: POST /library/files/{id}/slice + /archives/{id}/slice

    - Body now accepts source-aware {source, id} triplets per slot:
        printer_preset:  PresetRef
        process_preset:  PresetRef
        filament_preset: PresetRef
    - Legacy *_preset_id integer fields kept for backwards-compat. The
      schema validator normalises bare ints into
      PresetRef(source='local', id=str(int)) so the route handler only
      deals with one shape.

  New preset_resolver service fetches the JSON content per source:

    - cloud:    BambuCloudService.get_setting_detail(id), unwraps the
                `setting` envelope (falls back to top-level for minor
                shape variants).
    - local:    DB read with preset_type slot validation (existing path,
                factored into the new helper).
    - standard: minimal {name, inherits, from: "system"} stub — the
                sidecar's profile-resolver flattens it against
                BUNDLED_PROFILES_PATH/<category>/<name>.json with no
                preset-content round-trip from Bambuddy.

  PERMISSIONS

    - Listing route gate: LIBRARY_UPLOAD (matches the slice action — any
      user who can slice can populate the dropdowns).
    - Cloud branch in BOTH the listing helper and the resolver checks
      CLOUD_AUTH independently — a user with LIBRARY_UPLOAD but not
      CLOUD_AUTH doesn't see the cloud tier (returns 403 if they try
      to slice with a cloud preset) even if a leftover User.cloud_token
      survived a permission revocation. Cloud listing path
      short-circuits the token lookup entirely on the gate-fail branch.

  FRONTEND — SliceModal

    - Calls api.getSlicerPresets() instead of api.getLocalPresets().
    - Dropdowns render <optgroup> per tier with localised section
      labels (Cloud / Imported / Standard).
    - Default selection follows cloud > local > standard priority on
      first load (auto-pick fires once when the data arrives, manual
      choices stick after that).
    - Cloud-status banner renders three variants
      (sign-in / expired / unreachable) only when status != 'ok'.
    - Slice button submits source-aware refs; legacy integer payload
      is preserved server-side for older clients.

  3MF PROFILE-PATH HARDENING (shipped together because they touch the
  same code paths)

  (1) Strip widened. _strip_3mf_embedded_settings only removed
      Metadata/project_settings.config. Real-world Bambu Studio /
      OrcaSlicer 3MFs also carry model_settings.config, slice_info.config,
      and cut_information.xml — any single leftover trips the CLI's
      input validation and the slice falls back to embedded settings,
      making the SliceModal's profile picker theatrical for 3MF inputs.
      Now removes all four configs via a centralised
      _STRIPPABLE_3MF_CONFIGS frozenset with per-file rationale;
      geometry (3D/3dmodel.model), thumbnails, multi-part data
      preserved.

  (2) Sidecar 5xx error capture. slicer_api.py was reading only
      `message` from sidecar 5xx responses and dropping `details`, so
      every CLI failure surfaced as the unhelpful generic
      "Failed to slice the model". New _format_sidecar_error helper
      combines both fields, falls back to plain-text body for
      non-JSON 5xx (nginx 502s, gateway timeouts), replaces the four
      duplicated extraction blocks. Pairs with the orca-slicer-api
      fork's bambuddy/profile-resolver branch which now emits
      `details` on AppError responses (d9c6121) and captures CLI
      stderr in the failure path (fb928c8).

  CARE TAKEN — additive on existing surfaces

    - main.py:               +1 import, +1 router register
    - slicer_api.py:         +list_bundled_profiles, +_format_sidecar_error
                             (dedupes the 4 message-extraction blocks);
                             no existing method behaviour changed
    - library.py:            resolver swap inside _run_slicer_with_fallback,
                             user_id threaded through two callers,
                             strip widened
    - schemas/slicer.py:     PresetRef added, *_preset fields added,
                             legacy *_preset_id kept; validator normalises
    - 4 new files:           schema, route, resolver, tests
    - No existing route URL changed, no existing field removed, no
      behaviour change for clients still sending bare integer ids.

  TESTS

    - 17 unit tests for the listing endpoint helpers
    - 11 unit tests for the source-aware resolver
    - 6 schema tests for SliceRequest legacy + new shapes
    - 3 unit tests for the new sidecar error-detail capture
    - Strip integration test extended to assert all 4 configs go and
      geometry stays
    - 12 frontend tests for SliceModal covering tier-priority
      auto-selection, <optgroup> grouping, fallback paths, source-aware
      payload on submit, manual override across tiers, archive vs
      library routing, error display, all three banner variants

  Verified: 3394 backend + 1531 frontend tests pass, ruff clean,
  frontend production build clean.

  Pairs with three already-pushed commits on the orca-slicer-api fork's
  bambuddy/profile-resolver branch:

    - 5fd6bc6  feat(profiles): add GET /profiles/bundled
    - d9c6121  fix(error): include causeMessage in JSON response as `details`
    - fb928c8  fix(slicing): include CLI stdout/stderr in failure causeMessage

frontend/src/components/SliceModal.tsx

@@ -1,8 +1,16 @@
-import { Cog, Loader2, X } from 'lucide-react';
-import { useState } from 'react';
+import { Cloud, CloudOff, Cog, Loader2, X } from 'lucide-react';
+import { useEffect, useMemo, useState } from 'react';
 import { useTranslation } from 'react-i18next';
 import { useMutation, useQuery } from '@tanstack/react-query';
-import { api, type LocalPreset } from '../api/client';
+import {
+  api,
+  type PresetRef,
+  type PresetSource,
+  type SlicerCloudStatus,
+  type UnifiedPreset,
+  type UnifiedPresetsBySlot,
+  type UnifiedPresetsResponse,
+} from '../api/client';
 import { useSliceJobTracker } from '../contexts/SliceJobTrackerContext';
 
 export type SliceSource =
@@ -14,30 +22,72 @@ interface SliceModalProps {
   onClose: () => void;
 }
 
+type Slot = 'printer' | 'process' | 'filament';
+
+function pickDefault(by: UnifiedPresetsResponse, slot: Slot): PresetRef | null {
+  // Cloud > local > standard. The endpoint already deduplicates by name, so
+  // no name-collision handling needed here — first non-empty tier wins.
+  for (const tier of ['cloud', 'local', 'standard'] as const) {
+    const list = by[tier][slot];
+    if (list.length > 0) {
+      return { source: list[0].source, id: list[0].id };
+    }
+  }
+  return null;
+}
+
+function toRefValue(ref: PresetRef | null): string {
+  // The HTML `<select>` value space is flat strings; encode source + id so
+  // the same preset name can live in multiple tiers without collision.
+  return ref ? `${ref.source}:${ref.id}` : '';
+}
+
+function fromRefValue(raw: string): PresetRef | null {
+  if (!raw) return null;
+  const idx = raw.indexOf(':');
+  if (idx < 0) return null;
+  const source = raw.slice(0, idx) as PresetSource;
+  const id = raw.slice(idx + 1);
+  if (source !== 'cloud' && source !== 'local' && source !== 'standard') return null;
+  return { source, id };
+}
+
 export function SliceModal({ source, onClose }: SliceModalProps) {
   const { t } = useTranslation();
   const { trackJob } = useSliceJobTracker();
 
-  const [printerPresetId, setPrinterPresetId] = useState<number | null>(null);
-  const [processPresetId, setProcessPresetId] = useState<number | null>(null);
-  const [filamentPresetId, setFilamentPresetId] = useState<number | null>(null);
+  const [printerPreset, setPrinterPreset] = useState<PresetRef | null>(null);
+  const [processPreset, setProcessPreset] = useState<PresetRef | null>(null);
+  const [filamentPreset, setFilamentPreset] = useState<PresetRef | null>(null);
   const [errorMessage, setErrorMessage] = useState<string | null>(null);
 
   const presetsQuery = useQuery({
-    queryKey: ['localPresets'],
-    queryFn: () => api.getLocalPresets(),
+    queryKey: ['slicerPresets'],
+    queryFn: () => api.getSlicerPresets(),
     staleTime: 60_000,
   });
 
+  // Default selection: cloud > local > standard. Runs only on the first
+  // successful load; subsequent re-renders preserve the user's manual choice.
+  useEffect(() => {
+    if (!presetsQuery.data) return;
+    if (printerPreset == null) setPrinterPreset(pickDefault(presetsQuery.data, 'printer'));
+    if (processPreset == null) setProcessPreset(pickDefault(presetsQuery.data, 'process'));
+    if (filamentPreset == null) setFilamentPreset(pickDefault(presetsQuery.data, 'filament'));
+    // Intentionally exclude state-setters and current selections from deps —
+    // we only want the auto-pick to fire once when data first arrives.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [presetsQuery.data]);
+
   const enqueueMutation = useMutation({
     mutationFn: async () => {
-      if (printerPresetId == null || processPresetId == null || filamentPresetId == null) {
+      if (!printerPreset || !processPreset || !filamentPreset) {
         throw new Error('All three presets must be selected');
       }
       const body = {
-        printer_preset_id: printerPresetId,
-        process_preset_id: processPresetId,
-        filament_preset_id: filamentPresetId,
+        printer_preset: printerPreset,
+        process_preset: processPreset,
+        filament_preset: filamentPreset,
       };
       if (source.kind === 'libraryFile') {
         return api.sliceLibraryFile(source.id, body);
@@ -45,8 +95,6 @@ export function SliceModal({ source, onClose }: SliceModalProps) {
       return api.sliceArchive(source.id, body);
     },
     onSuccess: (enqueue) => {
-      // Hand the job off to the global tracker — polling, toasts, and
-      // query invalidation continue across navigation.
       trackJob(enqueue.job_id, source.kind, source.filename);
       onClose();
     },
@@ -56,7 +104,7 @@ export function SliceModal({ source, onClose }: SliceModalProps) {
     },
   });
 
-  const isReady = printerPresetId != null && processPresetId != null && filamentPresetId != null;
+  const isReady = printerPreset != null && processPreset != null && filamentPreset != null;
   const isEnqueuing = enqueueMutation.isPending;
 
   return (
@@ -104,32 +152,36 @@ export function SliceModal({ source, onClose }: SliceModalProps) {
             <div className="text-sm text-red-400" role="alert">
               {t(
                 'slice.presetsLoadFailed',
-                'Failed to load presets. Open Settings → Profiles to import them first.',
+                'Failed to load presets. Open Settings → Profiles to import them, or sign in to Bambu Cloud.',
               )}
             </div>
           )}
 
           {presetsQuery.data && (
             <>
+              <CloudStatusBanner status={presetsQuery.data.cloud_status} />
               <PresetDropdown
                 label={t('slice.printer', 'Printer profile')}
-                presets={presetsQuery.data.printer}
-                value={printerPresetId}
-                onChange={setPrinterPresetId}
+                slot="printer"
+                data={presetsQuery.data}
+                value={printerPreset}
+                onChange={setPrinterPreset}
                 disabled={isEnqueuing}
               />
               <PresetDropdown
                 label={t('slice.process', 'Process profile')}
-                presets={presetsQuery.data.process}
-                value={processPresetId}
-                onChange={setProcessPresetId}
+                slot="process"
+                data={presetsQuery.data}
+                value={processPreset}
+                onChange={setProcessPreset}
                 disabled={isEnqueuing}
               />
               <PresetDropdown
                 label={t('slice.filament', 'Filament profile')}
-                presets={presetsQuery.data.filament}
-                value={filamentPresetId}
-                onChange={setFilamentPresetId}
+                slot="filament"
+                data={presetsQuery.data}
+                value={filamentPreset}
+                onChange={setFilamentPreset}
                 disabled={isEnqueuing}
               />
             </>
@@ -176,30 +228,92 @@ export function SliceModal({ source, onClose }: SliceModalProps) {
   );
 }
 
+function CloudStatusBanner({ status }: { status: SlicerCloudStatus }) {
+  const { t } = useTranslation();
+  if (status === 'ok') return null;
+
+  // Map each non-ok status to the appropriate icon + tone. None of these are
+  // hard errors — the user can still slice using local + standard presets,
+  // so we use info / warn styling rather than error red.
+  const config: Record<Exclude<SlicerCloudStatus, 'ok'>, { tone: string; icon: typeof Cloud; key: string; fallback: string }> = {
+    not_authenticated: {
+      tone: 'border-bambu-dark-tertiary/40 bg-bambu-dark text-bambu-gray',
+      icon: Cloud,
+      key: 'slice.cloud.notAuthenticated',
+      fallback: 'Sign in to Bambu Cloud (Settings → Profiles → Cloud) to see your cloud presets.',
+    },
+    expired: {
+      tone: 'border-amber-700/40 bg-amber-900/20 text-amber-200',
+      icon: CloudOff,
+      key: 'slice.cloud.expired',
+      fallback: 'Bambu Cloud session expired — sign in again to refresh your cloud presets.',
+    },
+    unreachable: {
+      tone: 'border-bambu-dark-tertiary/40 bg-bambu-dark text-bambu-gray',
+      icon: CloudOff,
+      key: 'slice.cloud.unreachable',
+      fallback: 'Bambu Cloud is unreachable right now. Local and standard presets still work.',
+    },
+  };
+  const { tone, icon: Icon, key, fallback } = config[status];
+  return (
+    <div className={`flex items-start gap-2 text-xs rounded-md border p-2 ${tone}`} role="status">
+      <Icon className="w-4 h-4 flex-shrink-0 mt-0.5" />
+      <span>{t(key, fallback)}</span>
+    </div>
+  );
+}
+
 interface PresetDropdownProps {
   label: string;
-  presets: LocalPreset[];
-  value: number | null;
-  onChange: (id: number | null) => void;
+  slot: Slot;
+  data: UnifiedPresetsResponse;
+  value: PresetRef | null;
+  onChange: (ref: PresetRef | null) => void;
   disabled?: boolean;
 }
 
-function PresetDropdown({ label, presets, value, onChange, disabled }: PresetDropdownProps) {
+function PresetDropdown({ label, slot, data, value, onChange, disabled }: PresetDropdownProps) {
   const { t } = useTranslation();
+
+  const sections: { tierLabel: string; entries: UnifiedPreset[] }[] = useMemo(() => {
+    const tiers: { key: keyof UnifiedPresetsResponse; tier: 'cloud' | 'local' | 'standard'; label: string; fallback: string }[] = [
+      { key: 'cloud', tier: 'cloud', label: 'slice.tier.cloud', fallback: 'Cloud' },
+      { key: 'local', tier: 'local', label: 'slice.tier.local', fallback: 'Imported' },
+      { key: 'standard', tier: 'standard', label: 'slice.tier.standard', fallback: 'Standard' },
+    ];
+    return tiers
+      .map(({ key, label: lk, fallback }) => ({
+        tierLabel: t(lk, fallback),
+        entries: (data[key] as UnifiedPresetsBySlot)[slot],
+      }))
+      .filter((s) => s.entries.length > 0);
+  }, [data, slot, t]);
+
+  const totalEntries = sections.reduce((sum, s) => sum + s.entries.length, 0);
+
   return (
     <label className="block">
       <span className="block text-xs text-bambu-gray mb-1">{label}</span>
       <select
-        value={value ?? ''}
-        onChange={(e) => onChange(e.target.value ? Number(e.target.value) : null)}
-        disabled={disabled}
+        value={toRefValue(value)}
+        onChange={(e) => onChange(fromRefValue(e.target.value))}
+        disabled={disabled || totalEntries === 0}
         className="w-full px-3 py-2 rounded-md bg-bambu-dark border border-bambu-dark-tertiary text-white text-sm focus:outline-none focus:border-bambu-gray disabled:opacity-50"
       >
-        <option value="">{t('slice.selectPreset', '— Select a preset —')}</option>
-        {presets.map((p) => (
-          <option key={p.id} value={p.id}>
-            {p.name}
-          </option>
+        <option value="">
+          {totalEntries === 0
+            ? t('slice.noPresetsForSlot', 'No presets available')
+            : t('slice.selectPreset', '— Select a preset —')}
+        </option>
+        {sections.map((section) => (
+          <optgroup key={section.tierLabel} label={section.tierLabel}>
+            {section.entries.map((p) => (
+              <option key={`${p.source}:${p.id}`} value={`${p.source}:${p.id}`}>
+                {p.name}
+              </option>
+            ))}
+          </optgroup>
         ))}
       </select>
     </label>