============================================================
 LIMBFORGE — MEASUREMENT STUDIO FAULT AUDIT
============================================================
UTC: 2026-08-04T09:27:47+00:00

------------------------------------------------------------
1. CURRENT HEALTH
------------------------------------------------------------
http://127.0.0.1:8787/health                                             200
http://127.0.0.1:8786/health                                             200
http://127.0.0.1:8787/agents/limbforge/                                  200
http://127.0.0.1:8787/agents/limbforge/new-cover                         200

------------------------------------------------------------
2. MEASUREMENT STUDIO AND ROUTE REFERENCES
------------------------------------------------------------
Matching source lines: 281
src/App.jsx:22: import Measurements from '@/pages/Measurements';
src/App.jsx:23: import MeasurementSession from '@/pages/MeasurementSession';
src/App.jsx:123: <Route path="/new-cover" element={<NewCover />} />
src/App.jsx:124: <Route path="/measurements" element={<Measurements />} />
src/App.jsx:125: <Route path="/measurements/:uuid" element={<MeasurementSession />} />
src/components/ViewportErrorBoundary.jsx:65: All workshop records — customers, limb profiles, prostheses, components and measurements — remain available in the non-3D pages.
src/components/dimensions/DimensionEntryForm.jsx:2: import { MEASUREMENT_SOURCES } from '@/services/dimensionDefinitions';
src/components/dimensions/DimensionEntryForm.jsx:4: const [f, setF] = useState({ dimension_key: '', value: '', entered_unit: 'mm', source: 'Workshop Physical Measurement', confidence: 'High' });
src/components/dimensions/DimensionEntryForm.jsx:22: <label className="text-sm text-slate-300">Measurement source
src/components/dimensions/DimensionEntryForm.jsx:24: {MEASUREMENT_SOURCES.map(s => <option key={s}>{s}</option>)}
src/components/dimensions/tabs/MeasurementStationsTab.jsx:5: export default function MeasurementStationsTab({ component, actor }) {
src/components/dimensions/tabs/MeasurementStationsTab.jsx:16: <p className="text-sm text-slate-400">Vertical measurement stations along the Z axis (proximal to distal). Origin: alignment reference point or pivot centre.</p>
src/components/dimensions/tabs/MeasurementStationsTab.jsx:21: <div className="rounded-xl border border-dashed border-white/10 p-8 text-center text-slate-500"><p className="text-sm">No measurement stations recorded yet.</p></div>
src/components/dimensions/tabs/RevisionHistoryTab.jsx:10: <p className="text-sm text-slate-400">Every dimension change is preserved. Old measurements are never overwritten — re-measurements create new records.</p>
src/components/measurements/MeasurementEntry.jsx:2: export default function MeasurementEntry({ definition, onSave, onSkip, busy }) { const [value,setValue]=useState(''); const [unit,setUnit]=useState('mm'); const [confidence,setConfidence]=useState('High'); const [notes,setNotes]=useState(''); const [reason,setReason]=useState(''); const [photo,setPhoto]=useState(null); return <div className="space-y-5"><div className="grid gap-4 sm:grid-cols-3"><label className="text-sm text-slate-300 sm:col-span-2">Value<input autoFocus type="number" step="any" inputMode="decimal" className="workshop-input text-2xl" value={value} onChange={e=>setValue(e.target.value)} aria-label={`${definition.name} value`}/></label><label className="text-sm text-slate-300">Unit<select className="workshop-input" value={unit} onChange={e=>setUnit(e.target.value)}><option>mm</option><option>cm</option></select></label><label className="text-sm text-slate-300">Confidence<select className="workshop-input" value={confidence} onChange={e=>setConfidence(e.target.value)}><option>High</option><option>Medium</option><option>Low</option></select></label><label className="text-sm text-slate-300 sm:col-span-2">Notes<input className="workshop-input" value={notes} onChange={e=>setNotes(e.target.value)}/></label><label className="text-sm text-slate-300 sm:col-span-3">Optional photograph<input type="file" accept="image/*" className="workshop-input" onChange={e=>setPhoto(e.target.files?.[0]||null)}/></label></div><button disabled={busy||!value} onClick={()=>onSave({value,entered_unit:unit,confidence,notes,photo})} className="btn-primary w-full">{busy?'Saving…':'Save & continue'}</button><div className="flex gap-2"><input className="workshop-input mt-0" placeholder="Reason required to skip" value={reason} onChange={e=>setReason(e.target.value)}/><button disabled={!reason||busy} onClick={()=>onSkip(reason)} className="btn-secondary shrink-0">Skip</button></div></div> }
src/components/measurements/MeasurementGuide.jsx:2: export default function MeasurementGuide({ definition }) { return <div className="panel p-6"><div className="mb-5 flex aspect-video items-center justify-center rounded-xl border border-dashed border-violet-400/20 bg-violet-400/5"><div className="text-center text-slate-500"><Move3D className="mx-auto mb-2 h-10 w-10"/><p className="text-sm">Measurement location diagram</p><p className="text-xs">Dedicated diagram not yet implemented</p></div></div><h2 className="text-2xl font-semibold text-white">{definition.name}</h2><p className="mt-3 leading-7 text-slate-300">{definition.explanation}</p><div className="mt-5 flex items-center gap-3 rounded-xl bg-slate-900 p-4 text-sm text-slate-300"><Ruler className="h-5 w-5 text-violet-400"/><span><strong>Required tool:</strong> {definition.required_tool}</span></div></div> }
src/components/measurements/SessionCard.jsx:3: export default function SessionCard({ session, project }) { return <article className="panel p-5"><div className="flex items-start justify-between"><div><p className="text-xs font-semibold text-violet-400">{project?.project_id || session.project_uuid}</p><h2 className="mt-1 text-lg font-semibold text-white">{session.workflow}</h2></div><StatusPill tone={session.status==='Complete'?'green':'amber'}>{session.status}</StatusPill></div><div className="mt-5 h-2 overflow-hidden rounded-full bg-slate-800"><div className="h-full rounded-full bg-violet-400 transition-all" style={{width:`${session.progress_percent||0}%`}}/></div><p className="mt-2 text-xs text-slate-500">{session.progress_percent||0}% complete</p><Link to={`/measurements/${session.uuid}`} className="btn-primary mt-4 block text-center">{session.status==='Not started'?'Start workflow':'Continue workflow'}</Link></article> }
src/components/measurements/StartWorkflowDialog.jsx:18: const start = async () => { const component = components.find(c => c.uuid === sel.component_uuid); const tasks = await dimensionAnalysis.buildWorkflow(component); const session = await dimensionService.createSession('component_envelope', { customer_uuid: sel.customer_uuid, limb_profile_uuid: sel.limb_uuid, component_uuid: sel.component_uuid }, 'Ray'); navigate(`/measurements/${session.uuid}`); };
src/components/newcover/NewCoverWizard.jsx:91: status: 'Awaiting measurements',
src/components/newcover/NewCoverWizard.jsx:259: !!data.measurement_method,
src/components/newcover/WizardStep.jsx:426: The project may proceed to measurements and
src/components/newcover/WizardStep.jsx:438: return select('measurement_method', methods);
src/components/newcover/WizardStep.jsx:509: Measurement method:
src/components/newcover/WizardStep.jsx:511: {data.measurement_method || 'Missing'}
src/components/newcover/wizardConfig.js:6: 'Measurement method',
src/components/newcover/wizardConfig.js:48: 'Manual measurements',
src/components/newcover/wizardConfig.js:50: 'Combination of manual measurements and 3D scan',
src/components/ui/image.jsx:101: // `size` is null exactly once: the pre-measurement first render, which we
src/components/ui/image.jsx:117: // useLayoutEffect, so nothing is lost: measurement lands before the
src/components/viewportV2/BabylonViewportV2.jsx:6: import { buildMeasurementStations } from './MeasurementStationsV2';
src/components/viewportV2/BabylonViewportV2.jsx:68: if (stationsRef.current && !compat) activeLayers.push('Measurement stations');
src/components/viewportV2/BabylonViewportV2.jsx:127: const s = buildMeasurementStations(scene);
src/components/viewportV2/BabylonViewportV2.jsx:347: return { prosthesis: 'Prosthesis', stations: 'Measurement layer', cover: 'Cover layer', branding: 'Branding layer', design: 'Design layer', ossiguard: 'Ossiguard layer' }[k] || k;
src/components/viewportV2/MeasurementStationsV2.js:19: export function buildMeasurementStations(scene) {
src/components/viewportV2/MeasurementStationsV2.js:31: ring.metadata = { type: 'measurementStation', stationId: s.id, stationName: s.name, value: null, index: i };
src/components/workshop/navItems.js:8: ['New Cover','/new-cover',PlusCircle],
src/components/workshop/navItems.js:9: ['Measurement Studio','/measurements',Ruler],
src/components/workshop3d/ContextInspectorV2.jsx:4: import { saveStationMeasurement, GEOMETRY_STATUS, STATUS_TONE } from '@/services/measurementGeometryService';
src/components/workshop3d/ContextInspectorV2.jsx:37: const isStation = kind === 'measurementStation';
src/components/workshop3d/ContextInspectorV2.jsx:85: await saveStationMeasurement({
src/components/workshop3d/ContextInspectorV2.jsx:106: await saveStationMeasurement({ sessionUuid: sessionId, componentUuid: componentUuid || 'generic', station: { station_name: name, notes: 'Not applicable', shape_classification: 'Not applicable' } });
src/components/workshop3d/ContextInspectorV2.jsx:126: <p className="text-xs text-slate-600">Measurement stations show live entry. Parts show component data. The cover shows geometry status.</p>
src/components/workshop3d/ContextInspectorV2.jsx:136: {existing ? <Pill tone="green"><CheckCircle2 className="h-3 w-3" />Recorded — review required</Pill> : <Pill tone="red"><XCircle className="h-3 w-3" />Measurement required</Pill>}
src/components/workshop3d/ContextInspectorV2.jsx:148: <p className="text-[11px] text-slate-500">{sessionId ? 'Saves to the active measurement session and updates the 3D model.' : 'No active session — select or create a session first.'}</p>
src/components/workshop3d/ContextInspectorV2.jsx:173: <Field label="Foot length" hint="Measurement required" />
src/components/workshop3d/ContextInspectorV2.jsx:174: <Field label="Maximum width" hint="Measurement required" />
src/components/workshop3d/ContextInspectorV2.jsx:175: <Field label="Heel height" hint="Measurement required" />
src/components/workshop3d/ContextInspectorV2.jsx:176: <Field label="Toe spring" hint="Measurement required" />
src/components/workshop3d/ContextInspectorV2.jsx:177: <Field label="Ankle position" hint="Measurement required" />
src/components/workshop3d/ContextInspectorV2.jsx:211: <Field label="Global clearance" hint="Measurement required" />
src/components/workshop3d/ProstheticAssembly.jsx:11: * Label: "Generic visual measurement model — dimensions must be verified before CAD."
src/components/workshop3d/ProstheticAssembly.jsx:92: { id: 'asm-disclaimer', position: [0, 224, 0], title: 'Generic visual measurement model', subtitle: 'dimensions must be verified before CAD', tone: 'amber' },
src/components/workshop3d/SceneComposer.jsx:47: <SceneFeatureBoundary name="Measurement rings">
src/components/workshop3d/SceneComposer.jsx:48: <StationRings stations={stations} selectedId={selectedId} onSelect={onSelect} visible={effectiveShow.measurements} highlightedIndex={highlightedStation} />
src/components/workshop3d/SceneComposer.jsx:52: <DimensionLabels dimensions={dimensions} stations={stations} visible={effectiveShow.measurements} />
src/components/workshop3d/StationRings.jsx:20: : 'Measurement required';
src/components/workshop3d/ViewportLabelLayer.jsx:6: * Renders measurement labels, warnings and callouts as ordinary React DOM
src/components/workshop3d/limbGeometry.js:3: // Example measurement stations for the generic visual model.
src/components/workshop3d/panels/ContextPanel.jsx:40: let label = 'No measurement session';
src/components/workshop3d/panels/ContextPanel.jsx:88: <AlertTriangle className="mr-1.5 inline h-3.5 w-3.5" />Workshop measurement required — link a physical component record to load verified dimensions. Dimensions must be verified before CAD.
src/components/workshop3d/panels/ContextPanel.jsx:131: <div className="flex items-center justify-between py-1"><span className="text-sm text-slate-400">Measurement status</span><CompletionBadge sessions={sessions} projectUuids={custProjects.map(p => p.uuid)} /></div>
src/components/workshop3d/panels/ContextPanel.jsx:171: <div className="flex items-center justify-between py-1"><span className="text-sm text-slate-400">Measurement status</span><CompletionBadge sessions={sessions} projectUuids={limbProjects.map(p => p.uuid)} /></div>
src/components/workshop3d/panels/ContextPanel.jsx:173: Visual model: generic until a verified component model is loaded. No measurements are invented.
src/components/workshop3d/panels/ContextPanel.jsx:206: {linkedComps.length === 0 ? <p className="text-sm italic text-slate-500">No components linked — workshop measurement required</p> : linkedComps.map(c => (
src/components/workshop3d/panels/ContextPanel.jsx:219: // ---- Measurement station (fallback path; browse mode uses MeasurementInspector) ----
src/components/workshop3d/panels/ContextPanel.jsx:224: <div className="border-b border-white/10 px-4 py-3"><h2 className="text-xs font-semibold uppercase tracking-[0.14em] text-slate-400">Measurement Station</h2></div>
src/components/workshop3d/panels/ContextPanel.jsx:229: <Field label="Total width" value={s.total_width_mm || s.width} unit="mm" placeholder="Measurement required" />
src/components/workshop3d/panels/ContextPanel.jsx:230: <Field label="Total depth" value={s.total_depth_mm || s.depth} unit="mm" placeholder="Measurement required" />
src/components/workshop3d/panels/ContextPanel.jsx:254: <Field label="Manufacturer" value={c.manufacturer} placeholder={selected.placeholder ? 'Workshop measurement required' : 'Not recorded'} />
src/components/workshop3d/panels/ContextPanel.jsx:255: <Field label="Model" value={c.model} placeholder={selected.placeholder ? 'Workshop measurement required' : 'Not recorded'} />
src/components/workshop3d/panels/ContextPanel.jsx:262: <Field label="System height" value={getVal('system_height_mm')} unit="mm" placeholder="Workshop measurement required" />
src/components/workshop3d/panels/ContextPanel.jsx:263: <Field label="Max width" value={getVal('overall_max_width')} unit="mm" placeholder="Workshop measurement required" />
src/components/workshop3d/panels/ContextPanel.jsx:264: <Field label="Max depth" value={getVal('overall_max_depth')} unit="mm" placeholder="Workshop measurement required" />
src/components/workshop3d/panels/MeasurementInspector.jsx:5: const SOURCES = ['Manufacturer Verified', 'Workshop Measurement', 'Verified 3D Scan', 'Customer Reported', 'Calculated', 'Estimated', 'Unknown'];
src/components/workshop3d/panels/MeasurementInspector.jsx:17: export default function MeasurementInspector({ selected, component, stationIndex, onSave, onMeasureAgain, onNotApplicable, previousValue, onAddPhoto }) {
src/components/workshop3d/panels/MeasurementInspector.jsx:19: const name = s.name || s.station_name || (stationIndex != null ? `Station ${String(stationIndex + 1).padStart(2, '0')}` : 'Measurement');
src/components/workshop3d/panels/MeasurementInspector.jsx:42: {stationIndex != null ? `Measurement Station ${String(stationIndex + 1).padStart(2, '0')}` : 'Measurement'}
src/components/workshop3d/panels/MeasurementInspector.jsx:51: <div className="mb-1 text-xs font-semibold uppercase tracking-[0.1em] text-slate-500">Measurement Name</div>
src/components/workshop3d/panels/MeasurementInspector.jsx:56: <input type="number" value={value} onChange={(e) => setValue(e.target.value)} placeholder="Measurement required — enter value" className="workshop-input flex-1 !min-h-10" />
src/components/workshop3d/panels/StationTable.jsx:10: <Layers className="h-3.5 w-3.5" /> Measurement Stations ({rows.length})
src/components/workshop3d/panels/VerticalToolStrip.jsx:6: { id: 'station', icon: Ruler, label: 'Add Measurement Station' },
src/components/workshop3d/panels/ViewportToolbar.jsx:15: { id: 'measurements', icon: Eye, label: 'Measurements' },
src/components/workshop3d/workflows/MeasurementStudio3D.jsx:2: import { measurementService } from '@/services/measurementService';
src/components/workshop3d/workflows/MeasurementStudio3D.jsx:18: export default function MeasurementStudio3D({ session, onGuidedView, onHighlightStation, onComplete, actor = 'Ray' }) {
src/components/workshop3d/workflows/MeasurementStudio3D.jsx:30: measurementService.definitions(session.workflow).then(defs => {
src/components/workshop3d/workflows/MeasurementStudio3D.jsx:54: <p className="text-sm text-slate-400">No active measurement session.</p>
src/components/workshop3d/workflows/MeasurementStudio3D.jsx:55: <p className="mt-1 text-xs text-slate-500">Start a session from the Measurement Studio to begin guided 3D recording.</p>
src/components/workshop3d/workflows/MeasurementStudio3D.jsx:64: <p className="text-sm text-slate-300">All measurements complete.</p>
src/components/workshop3d/workflows/MeasurementStudio3D.jsx:74: const saved = await measurementService.save(session, current, { value: Number(value), entered_unit: enteredUnit, confidence, notes, photo_url: '' }, actor);
src/components/workshop3d/workflows/MeasurementStudio3D.jsx:81: await measurementService.progress(session, definitions.length, definitions.length);
src/components/workshop3d/workflows/MeasurementStudio3D.jsx:93: await measurementService.skip(session, current, 'Not applicable for this limb', actor);
src/components/workshop3d/workflows/MeasurementStudio3D.jsx:105: <h2 className="text-xs font-semibold uppercase tracking-[0.14em] text-cyan-400">Guided 3D Measurement</h2>
src/components/workshop3d/workflows/MeasurementStudio3D.jsx:109: <p className="mt-1.5 text-xs text-slate-500">Measurement {index + 1} of {definitions.length} • {progress}%</p>
src/components/workshop3d/workflows/MeasurementStudio3D.jsx:130: <input type="number" value={value} onChange={e => setValue(e.target.value)} placeholder="Enter measurement" className="workshop-input flex-1" />
src/config/permissions.js:26: { group: 'Measurements', permissions: [
src/config/permissions.js:27: { key: 'measurements.record', label: 'Record measurements' },
src/config/permissions.js:28: { key: 'measurements.edit', label: 'Edit entered measurements' },
src/config/permissions.js:29: { key: 'measurements.verify', label: 'Verify measurements' },
src/config/permissions.js:30: { key: 'measurements.supersede', label: 'Supersede measurements' },
src/config/permissions.js:31: { key: 'measurements.export', label: 'Export measurements' },
src/config/permissions.js:77: 'measurements.record', 'measurements.edit',
src/config/permissions.js:90: permissions: [...builderBase, 'measurements.verify', 'measurements.supersede',
src/config/permissions.js:101: measurement_only: { label: 'Measurement Only', role: 'builder', permissions: ['customers.view_assigned', 'components.view', 'measurements.record', 'measurements.edit', 'measurements.verify'] },
src/config/permissions.js:107: 'Customer Review', 'Measurements', 'Prosthetic Components', 'Babylon 3D Mapping',
src/hooks/use-size.jsx:6: // useLayoutEffect (not useEffect): the initial measurement must land before
src/modes/customerIntakeConfig.js:1: export const customerIntakeMode = { exposed: false, allowedSteps: ['Start request','Contact details','Select limb','Select prosthesis type','Measurements','Photographs','Buttons and problem areas','Design preferences','Quote request','Funding selection','Declarations'], prohibitedData: ['Internal manufacturing files','Other customers','CAD settings','Internal costs','SHiREVault locations'] };
src/pages/ComponentDimensions.jsx:11: import MeasurementStationsTab from '@/components/dimensions/tabs/MeasurementStationsTab';
src/pages/ComponentDimensions.jsx:24: ['envelope', 'External Envelope', ExternalEnvelopeTab], ['stations', 'Measurement Stations', MeasurementStationsTab],
src/pages/CustomerDetail.jsx:21: const TABS = [['overview','Overview'],['limbs','Limb Profiles'],['prostheses','Prostheses & Components'],['measurements','Measurements'],['projects','Projects'],['quotes','Quotes'],['orders','Orders'],['covers','Completed Covers'],['history','History']];
src/pages/CustomerDetail.jsx:34: adapters.database.filter('MeasurementSession', { customer_uuid: uuid }),
src/pages/CustomerDetail.jsx:56: return <><Breadcrumbs items={[{ label: 'Customers', to: '/customers' }, { label: customer.full_name }]} /><PageHeader eyebrow={`${customer.customer_number} · ${customer.data_label}`} title={customer.full_name} description={`${customer.funding_method || 'Funding not selected'} · ${customer.approval_status || 'Approval not requested'}`} action={<div className="flex flex-wrap gap-2"><button className="btn-secondary" onClick={() => setMode('edit')}><Edit />Edit Customer</button><Link className="btn-primary" to="/new-cover"><PlusCircle />Start New Cover</Link><button className="btn-secondary" onClick={() => setMode('limb')}>Add Limb Profile</button><button className="btn-secondary" onClick={() => setMode('prosthesis')}>Add Prosthesis</button><Link className="btn-secondary" to="/measurements"><Ruler />Request Measurements</Link><button disabled={busy || !firstProject} onClick={prepareQuote} className="btn-secondary"><Receipt />Prepare Quote</button></div>} /><div className="mb-5 flex flex-wrap items-center gap-2"><StatusPill tone={customer.record_state === 'archived' ? 'slate' : 'green'}>{customer.record_state === 'archived' ? 'Archived' : 'Active'}</StatusPill>{returning && <StatusPill tone="cyan">Returning customer</StatusPill>}<OriginBadge record={customer} showAll /></div>
src/pages/CustomerDetail.jsx:70: {tab === 'measurements' && <section className="panel p-5"><h2 className="section-title">Measurement Sessions ({sessions.length})</h2>{sessions.length ? <div className="space-y-2">{sessions.map((s) => <Link key={s.uuid} to={`/measurements/${s.uuid}`} className="flex items-center justify-between rounded-lg border border-white/10 px-3 py-2 text-sm hover:border-shire-purple/40"><div><span className="font-medium text-violet-300">{s.workflow}</span><span className="ml-2 text-xs text-slate-500">{s.measured_date} · {s.measured_by}</span></div><div className="flex items-center gap-2"><StatusPill tone={s.status === 'Complete' ? 'green' : 'amber'}>{s.status}</StatusPill><span className="text-xs text-slate-500">{s.progress_percent || 0}%</span></div></Link>)}</div> : <p className="text-sm text-slate-500">No measurement sessions recorded.</p>}</section>}
src/pages/Customers.jsx:13: const FILTERS = ['All', 'New customers', 'Returning customers', 'Active projects', 'Awaiting measurements', 'Awaiting quote', 'Current orders', 'Completed customers', 'Archived'];
src/pages/Customers.jsx:39: else if (filter === 'Awaiting measurements') list = list.filter((c) => projects.some((p) => p.customer_uuid === c.uuid && p.status === 'Awaiting measurements'));
src/pages/Customers.jsx:49: return <><PageHeader eyebrow="Returning-customer records" title="Customers" description="Search and inspect every customer with their full project, measurement, order and cover history." action={<button onClick={() => setShow(true)} className="btn-primary"><Plus />New customer</button>} />{show && <div className="panel mb-6 p-6"><CustomerForm onSave={save} onCancel={() => setShow(false)} /></div>}<div className="mb-5 flex flex-wrap items-center gap-2"><label className="relative block"><Search className="absolute left-3 top-3 h-4 w-4 text-slate-500" /><input className="workshop-input mt-0 pl-10" placeholder="Search name, email, phone or customer number" value={search} onChange={(e) => setSearch(e.target.value)} /></label><select className="workshop-input mt-0 max-w-xs" value={filter} onChange={(e) => setFilter(e.target.value)}>{FILTERS.map((f) => <option key={f}>{f}</option>)}</select><select className="workshop-input mt-0 max-w-xs" value={sort} onChange={(e) => setSort(e.target.value)}>{SORTS.map((s) => <option key={s}>{s}</option>)}</select><HideFictionalToggle value={hideFictional} onChange={setHideFictional} /></div><div className="grid gap-4 md:grid-cols-2 xl:grid-cols-3">{filtered.map((c) => <CustomerCard key={c.uuid} customer={c} counts={counts[c.uuid]} onToggle={toggle} />)}</div>{filtered.length === 0 && <p className="mt-8 text-center text-sm text-slate-500">No customers match the current filter.</p>}</>;
src/pages/Dashboard.jsx:7: export default function Dashboard() { const [data,setData]=useState(null); useEffect(()=>{dashboardService.summary().then(setData)},[]); if(!data)return <LoadingPanel/>; const cards=[['Active cover projects',data.active,'/projects?active=true'],['Measurements awaiting completion',data.measurements,'/measurements?status=open'],['Awaiting customer clarification',data.clarification,'/projects?status=Awaiting+customer+clarification'],['Designs awaiting selection',data.selection,'/projects?status=Designs+awaiting+selection'],['Awaiting workshop review',data.review,'/projects?status=Awaiting+workshop+review'],['Quotes awaiting acceptance',0,'/not-implemented?feature=Quotes'],['Orders awaiting payment',0,'/not-implemented?feature=Orders'],['NDIS / plan approval',0,'/not-implemented?feature=Orders'],['Covers awaiting print',0,'/not-implemented?feature=Manufacturing'],['Currently printing',0,'/not-implemented?feature=Manufacturing'],['Awaiting final inspection',0,'/not-implemented?feature=Manufacturing'],['Ready to ship',0,'/not-implemented?feature=Shipping'],['Recently completed',data.completed.length,'/projects?status=Complete'],['Returning customers',data.returning,'/customers?returning=true']]; return <><PageHeader eyebrow="Private Prosthetic Cover Design and Production Studio" title="Workshop Dashboard" description="Live workshop records. Production areas not yet built show zero and are explicitly marked on opening."/><BoundaryNotice/><div className="mt-6 grid gap-4 sm:grid-cols-2 xl:grid-cols-4">{cards.map(c=><MetricCard key={c[0]} label={c[0]} value={c[1]} to={c[2]}/>)}</div><div className="mt-6 grid gap-4 md:grid-cols-3"><MetricCard label="SHiREVault connection" value="Unavailable" detail="Base44 cannot mount the private network drive" to="/migration-readiness"/><MetricCard label="Last verified export" value="None" detail="Not yet implemented — Stage 4" to="/migration-readiness"/><MetricCard label="Last verified backup" value="None" detail="Not claimed while Base44-hosted" to="/migration-readiness"/></div></> }
src/pages/DesignForge.jsx:17: import { loadProjectGeometry } from '@/services/measurementGeometryService';
src/pages/DesignYourCover.jsx:15: { id: 'measure', title: 'Measurements', icon: Ruler },
src/pages/DesignYourCover.jsx:30: measurements: { coverLength: '', calfWidth: '', ankleWidth: '', footLength: '', footWidth: '' },
src/pages/DesignYourCover.jsx:72: <p className="text-xs text-slate-500">Manufacturing has not started. A SHiRE team member will contact you via {form.contact_method.toLowerCase()} to verify measurements and confirm your design. No payment has been taken.</p>
src/pages/DesignYourCover.jsx:176: <p className="text-xs text-slate-500">Enter what you can — estimates are fine. We'll verify everything before manufacturing. All measurements in millimetres.</p>
src/pages/DesignYourCover.jsx:184: <TextInput key={k} label={label} type="number" value={form.measurements[k]} onChange={(v) => set({ measurements: { ...form.measurements, [k]: v } })} />
src/pages/DesignYourCover.jsx:236: <Row k="Measurements" v={countMeasures(form.measurements) ? `${countMeasures(form.measurements)} entered` : 'None — workshop will measure'} />
src/pages/DesignYourCover.jsx:245: <span className="text-xs text-slate-300">I understand this is a cosmetic, non-load-bearing cover; workshop review is required; measurements may need verification; the final design may require prosthetist approval; and manufacturing has not started.</span>
src/pages/IntakeRequests.jsx:18: let list = projects.filter((p) => p.data_origin === 'Public Intake' || /intake/i.test(p.reason_for_cover || '') || /intake/i.test(p.measurement_method || ''));
src/pages/MeasurementSession.jsx:4: import MeasurementGuide from '@/components/measurements/MeasurementGuide';
src/pages/MeasurementSession.jsx:5: import MeasurementEntry from '@/components/measurements/MeasurementEntry';
src/pages/MeasurementSession.jsx:9: import { measurementService } from '@/services/measurementService';
src/pages/MeasurementSession.jsx:17: export default function MeasurementSession() {
src/pages/MeasurementSession.jsx:28: const s = await measurementService.session(uuid);
src/pages/MeasurementSession.jsx:41: const [d, v] = await Promise.all([measurementService.definitions(s.workflow), measurementService.values(uuid)]);
src/pages/MeasurementSession.jsx:52: const advance = async (newIndex) => { const next = newIndex ?? (index + 1); setIndex(next); const total = tasks.length; const complete = Math.min(next, total); await measurementService.progress(session, complete, total); if (next >= total) load(); };
src/pages/MeasurementSession.jsx:57: if (data.photo) { const stored = await fileStorageService.uploadMeasurementPhoto(data.photo, session.project_uuid || session.component_uuid); photoUrl = stored.location; storageDest = stored.destination; }
src/pages/MeasurementSession.jsx:61: await dimensionService.saveDimension({ component_uuid: session.component_uuid, dimension_key: task.key, dimension_name: task.name, category: 'External envelope', source: 'Workshop Physical Measurement', value_mm, original_value: Number(data.value), original_unit: data.entered_unit, entered_unit: data.entered_unit, confidence: data.confidence, verification_status: 'Verified workshop value', entered_by: 'Ray', date_entered: today(), session_uuid: uuid, notes: data.notes, photo_url: photoUrl, storage_destination: storageDest }, 'Ray');
src/pages/MeasurementSession.jsx:63: await measurementService.save(session, tasks[index], data, 'Ray');
src/pages/MeasurementSession.jsx:68: const skip = async (reason) => { setBusy(true); if (!isComponent) await measurementService.skip(session, tasks[index], reason, 'Ray'); await advance(); setBusy(false); load(); };
src/pages/MeasurementSession.jsx:69: const pause = async () => { await measurementService.pause(session); navigate('/measurements'); };
src/pages/MeasurementSession.jsx:72: <div className="mx-auto max-w-2xl"><BoundaryNotice /><div className="panel mt-6 p-8 text-center"><p className="text-violet-400">MEASUREMENT SET COMPLETE</p><h1 className="mt-2 text-3xl font-semibold text-white">Ready for manual review</h1><p className="mt-3 text-slate-400">{values.filter(v => v.warning).length} saved warning(s) require review.</p><div className="mt-6 flex justify-center gap-3"><button onClick={() => setIndex(0)} className="btn-secondary"><RotateCcw />Review again</button>{isComponent && <Link to={`/components/${session.component_uuid}/dimensions`} className="btn-primary">Open component dimensions<ExternalLink /></Link>}</div></div></div>
src/pages/MeasurementSession.jsx:82: <Link to="/measurements" className="btn-secondary"><ChevronLeft />Back</Link>
src/pages/MeasurementSession.jsx:87: <MeasurementGuide definition={guideDef} />
src/pages/MeasurementSession.jsx:97: <MeasurementEntry key={task.uuid || task.key} definition={guideDef} onSave={save} onSkip={skip} busy={busy} />
src/pages/Measurements.jsx:5: import SessionCard from '@/components/measurements/SessionCard';
src/pages/Measurements.jsx:6: import StartWorkflowDialog from '@/components/measurements/StartWorkflowDialog';
src/pages/Measurements.jsx:7: import { measurementService } from '@/services/measurementService';
src/pages/Measurements.jsx:9: export default function Measurements() { const [sessions,setSessions]=useState([]); const [projects,setProjects]=useState([]); const [starting,setStarting]=useState(false); useEffect(()=>{Promise.all([measurementService.sessions(),projectService.list()]).then(([s,p])=>{setSessions(s);setProjects(p)})},[]); return <><PageHeader eyebrow="Guided recording" title="Measurement Studio" description="Measurements save immediately in millimetres and never overwrite historical sessions." action={<button className="btn-primary" onClick={()=>setStarting(true)}><Plus/>Start workflow</button>}/><BoundaryNotice/>{starting&&<StartWorkflowDialog onClose={()=>setStarting(false)} />}<div className="mt-6 grid gap-4 md:grid-cols-2 xl:grid-cols-3">{sessions.map(s=><SessionCard key={s.uuid} session={s} project={projects.find(p=>p.uuid===s.project_uuid)}/>)}</div></> }
src/pages/NewCover.jsx:6: export default function NewCover() { const [created,setCreated]=useState(null); return <><PageHeader eyebrow="Ten-step controlled intake" title="New Cover" description="Create a revisioned workshop project from customer, limb, components, measurements and design constraints."/><BoundaryNotice/>{created?<div className="panel mx-auto mt-6 max-w-2xl p-8 text-center"><p className="text-sm text-violet-400">PROJECT CREATED</p><h2 className="mt-2 text-3xl font-semibold text-white">{created.project_id}</h2><p className="mt-3 text-slate-400">Revision {created.revision} · {created.status}</p><div className="mt-6 flex justify-center gap-3"><Link className="btn-primary" to="/projects">Open projects</Link><button className="btn-secondary" onClick={()=>setCreated(null)}>Create another</button></div></div>:<div className="mt-6"><NewCoverWizard onCreated={setCreated}/></div>}</> }
src/pages/OrderDetail.jsx:16: const PRODUCTION = ['Awaiting measurements','Ready for design','Awaiting approval','Ready for CAD','CAD in progress','Test print','Fit review','Final print','Post-processing','Inspection','Ready to ship','Shipped','Delivered','Complete'];
src/pages/Orders.jsx:11: const FILTERS = ['All', 'Awaiting measurements', 'Awaiting NDIS/plan-manager approval', 'Ready for CAD', 'In manufacturing', 'Awaiting inspection', 'Ready to ship', 'Shipped', 'Delivered', 'Complete', 'Cancelled', 'Archived'];
src/pages/OssiguardWizard.jsx:148: return <Grid><TextInput label="Profile name" value={form.profile_name} onChange={(v) => set('profile_name', v)} full /><TextInput label="Version" value={form.version} onChange={(v) => set('version', v)} /><TextInput label="Revision" type="number" value={form.connector_revision} onChange={(v) => set('connector_revision', v)} /><Select label="Template / approval status" value={form.approval_status} onChange={(v) => set('approval_status', v)} options={['Prototype', 'Measurement Required', 'Workshop Verified', 'CAD Verified', 'Approved Connector Revision']} /><TextInput label="Designed by" value={form.designed_by} onChange={(v) => set('designed_by', v)} /><TextInput label="Date created" type="date" value={form.date_created} onChange={(v) => set('date_created', v)} /></Grid>;
src/pages/ProjectDetail.jsx:21: import { loadProjectGeometry } from '@/services/measurementGeometryService';
src/pages/ProjectDetail.jsx:27: const SECTIONS = [['customer','Customer'],['intake','Intake'],['measurements','Measurements'],['components','Components'],['ossiguard','Ossiguard'],['sensitive','Sensitive Zones'],['design','Design Brief'],['customDesign','Custom Design'],['validation','Validation'],['quote','Quote'],['order','Order'],['manufacturing','Manufacturing'],['covers','Completed Covers'],['audit','Audit']];
src/pages/ProjectDetail.jsx:56: adapters.database.filter('MeasurementSession', { project_uuid: projectId }),
src/pages/ProjectDetail.jsx:57: adapters.database.filter('MeasurementValue', { project_uuid: projectId }),
src/pages/ProjectDetail.jsx:99: checks.push(['At least one measurement session', data.sessions.length > 0, 'warning']);
src/pages/ProjectDetail.jsx:100: checks.push(['Measurements recorded', data.values.length > 0, 'warning']);
src/pages/ProjectDetail.jsx:123: return <><Breadcrumbs items={[{ label: 'Cover Projects', to: '/projects' }, { label: project.project_id }]} /><PageHeader eyebrow={`${project.project_id} · REV ${project.revision}`} title={customer?.full_name || 'Unknown customer'} description={`${project.prosthesis_configuration || 'Configuration not set'} · ${project.status}`} action={<div className="flex flex-wrap gap-2"><Link className="btn-primary" to={`/projects/${projectId}/design-forge`}><Sparkles />Open Design Forge</Link><button onClick={scrollToViewport} className="btn-secondary"><ScanLine />Open 3D Workshop</button><Link className="btn-secondary" to={`/customers/${project.customer_uuid}`}><Users />Open Customer</Link>{sessions[0] && <Link className="btn-secondary" to={`/measurements/${sessions[0].uuid}`}><Ruler />Open Measurements</Link>}<button disabled={busy} onClick={prepareQuote} className="btn-secondary"><Receipt />Prepare Quote</button>{orders[0] && <Link className="btn-secondary" to={`/orders/${orders[0].uuid}`}><ShoppingCart />View Order</Link>}</div>} /><div className="mb-5 flex flex-wrap items-center gap-2"><StatusPill tone={project.status === 'Complete' ? 'green' : 'amber'}>{project.status}</StatusPill>{geometry && <StatusPill tone={geometry.statusTone}>{geometry.geometryStatus}</StatusPill>}{quotes[0] && <StatusPill tone="cyan">Quote: {quotes[0].approval_status}</StatusPill>}{orders[0] && <StatusPill tone={orders[0].production_status === 'Complete' ? 'green' : 'amber'}>Order: {orders[0].production_status}</StatusPill>}{covers[0] && <StatusPill tone="green">Cover: {covers[0].cover_reference}</StatusPill>}<OriginBadge record={project} showAll /></div>
src/pages/ProjectDetail.jsx:130: {section === 'intake' && <section className="panel p-5"><h2 className="section-title">Public Intake Submission</h2>{project.data_origin === 'Public Intake' ? <FieldList columns={1} rows={[['Reason for cover', project.reason_for_cover], ['Cover boundaries', project.cover_boundaries], ['Sensitive area summary', project.sensitive_area_summary], ['Design preferences', project.design_preferences], ['Measurement method', project.measurement_method], ['Prosthesis configuration', project.prosthesis_configuration], ['Safety boundary accepted', project.safety_boundary_accepted ? 'Yes' : 'No']]} /> : <p className="text-sm text-slate-500">This project was created in the workshop (not from public intake). Original intake answers are not available.</p>}</section>}
src/pages/ProjectDetail.jsx:131: {section === 'measurements' && <section className="panel p-5"><h2 className="section-title">Measurement Sessions ({sessions.length}) · {values.length} values</h2>{sessions.length ? <div className="space-y-2">{sessions.map((s) => <div key={s.uuid} className="flex items-center justify-between rounded-lg border border-white/10 px-3 py-2"><div><span className="font-medium text-violet-300">{s.workflow}</span><span className="ml-2 text-xs text-slate-500">{s.measured_date} · {s.measured_by}</span></div><div className="flex items-center gap-2"><StatusPill tone={s.status === 'Complete' ? 'green' : 'amber'}>{s.status}</StatusPill><Link className="btn-secondary !py-1 text-xs" to={`/measurements/${s.uuid}`}>Open session</Link></div></div>)}</div> : <p className="text-sm text-slate-500">No measurement sessions. {sessions[0] ? '' : <Link className="text-violet-300" to="/measurements">Go to Measurement Studio</Link>}.</p>}</section>}
src/pages/ViewportV2Test.jsx:9: import { loadProjectGeometry } from '@/services/measurementGeometryService';
src/pages/ViewportV2Test.jsx:15: { id: 'measure', label: 'Measurement', icon: Ruler },
src/pages/ViewportV2Test.jsx:58: // auto-create a draft measurement session so station saves work immediately
src/pages/ViewportV2Test.jsx:61: const created = await base44.entities.MeasurementSession.create({
src/pages/ViewportV2Test.jsx:89: ? selection.type === 'measurementStation'
src/pages/ViewportV2Test.jsx:99: <p className="text-xs text-slate-500">Measurement-driven 3D — independent Babylon.js viewport.</p>
src/pages/Workshop3D.jsx:13: import MeasurementInspector from '@/components/workshop3d/panels/MeasurementInspector';
src/pages/Workshop3D.jsx:19: import MeasurementStudio3D from '@/components/workshop3d/workflows/MeasurementStudio3D';
src/pages/Workshop3D.jsx:29: import { measurementService } from '@/services/measurementService';
src/pages/Workshop3D.jsx:38: { to: '/new-cover', label: 'New Cover', icon: FolderKanban },
src/pages/Workshop3D.jsx:48: { id: null, label: 'Measurement Studio', icon: Ruler },
src/pages/Workshop3D.jsx:70: const [display, setDisplay] = useState({ measurements: true, sensitive: true, keepOut: true, access: true, cover: true, movement: true, logo: true });
src/pages/Workshop3D.jsx:111: measurementService.sessions().catch(() => []),
src/pages/Workshop3D.jsx:198: { type: 'stations-group', label: 'Measurement Stations', uuid: 'stations-group', children: stationNodes },
src/pages/Workshop3D.jsx:229: measurementService.sessions().then(ss => {
src/pages/Workshop3D.jsx:291: return <MeasurementStudio3D session={session} onGuidedView={setViewPreset} onHighlightStation={setHighlightedStation} onComplete={() => setActiveWorkflow(null)} />;
src/pages/Workshop3D.jsx:306: <MeasurementInspector
src/pages/Workshop3D.jsx:320: <Link to="/measurements" className="btn-secondary w-full !min-h-10">View All Measurements</Link>
src/pages/Workshop3D.jsx:326: const sessionStatus = session?.status === 'Complete' ? 'Session Complete' : session ? 'Live Capture' : 'Missing Measurements';
src/pages/Workshop3D.jsx:330: <TopBar route="/customers/ACME-0421/measurements" onLock={handleLock} />
src/pages/Workshop3D.jsx:390: <h1 className="text-lg font-semibold text-white">Measurement Studio</h1>
src/pages/Workshop3D.jsx:391: <p className="text-xs text-slate-500">Guided 3D capture with live measurement markers and design-ready prosthetic mapping.</p>
src/pages/Workshop3D.jsx:409: onReset={() => { setViewPreset('reset'); setDisplay(d => ({ ...d, measurements: true })); setCompatibility(false); }}
src/pages/Workshop3D.jsx:450: Select a component from the project tree to load its 3D model — a generic measurement model is shown meanwhile.
src/pages/Workshop3D.jsx:500: onDisableLayers={() => setDisplay({ measurements: false, access: false, keepOut: false, sensitive: false, movement: false, cover: false, logo: false })}
src/pages/Workshop3D.jsx:501: onReloadLayers={() => setDisplay({ measurements: true, access: true, keepOut: true, sensitive: true, movement: true, cover: true, logo: true })}
src/pages/admin/AdminUsers.jsx:88: <option value="measurement_only">Measurement Only</option>
src/pages/admin/Assignments.jsx:10: const TYPES = ['primary_builder', 'supporting_builder', 'measurement', 'design', 'ossiguard', 'manufacturing', 'inspection'];
src/pages/admin/Invitations.jsx:69: <option value="design_only">Design Only</option><option value="measurement_only">Measurement Only</option>
src/pages/admin/NewBuilder.jsx:49: <option value="design_only">Design Only</option><option value="measurement_only">Measurement Only</option>
src/pages/builder/BuilderProjectDetail.jsx:11: { key: 'measurements', label: 'Measurements', icon: Ruler, perm: 'measurements.record', entity: 'MeasurementSession', filter: 'project_uuid' },
src/pages/builder/BuilderProjectDetail.jsx:12: { key: 'design', label: 'Design Forge', icon: Sparkles, perm: 'design.use_forge', entity: 'DesignConfiguration', filter: 'project_uuid' },
src/pages/builder/BuilderWorkspace.jsx:65: {a.assignment_type === 'measurement' ? <Ruler className="h-4 w-4 text-violet-300" /> : a.assignment_type === 'design' ? <Sparkles className="h-4 w-4 text-violet-300" /> : a.assignment_type === 'manufacturing' || a.assignment_type === 'inspection' ? <Factory className="h-4 w-4 text-violet-300" /> : <ListChecks className="h-4 w-4 text-violet-300" />}
src/pages/portal/CustomerPortal.jsx:12: 'Awaiting measurements': 'Getting your measurements',
src/pages/portal/PortalDetail.jsx:11: quotes: 'Quote', orders: 'Order', 'completed-covers': 'CompletedCover', designs: 'DesignConfiguration',
src/pages/portal/PortalDetail.jsx:17: DesignConfiguration: ['concept_name', 'design_category', 'main_colour', 'accent_colour', 'finish', 'concept_status'],
src/pages/portal/PortalProject.jsx:27: setDesigns(await adapters.database.filter('DesignConfiguration', { project_uuid: projectId }));
src/pages/portal/PortalProject.jsx:52: await adapters.database.update('DesignConfiguration', d.id, { concept_status: 'Customer Preferred', customer_feedback: (d.customer_feedback || '') + ' [Marked preferred]' });
src/pages/portal/PortalProject.jsx:53: auditService.record('design_preference', 'DesignConfiguration', d.uuid, 'Customer marked design as preferred', account.display_name);
src/pages/portal/PortalProject.jsx:56: setDesigns(await adapters.database.filter('DesignConfiguration', { project_uuid: projectId }));
src/pages/portal/PortalProject.jsx:60: await adapters.database.update('DesignConfiguration', d.id, { concept_status: 'Approved for Quote', approved_for_quote: true });
src/pages/portal/PortalProject.jsx:61: auditService.record('design_approved', 'DesignConfiguration', d.uuid, 'Customer approved design for quote', account.display_name);
src/pages/portal/PortalProject.jsx:64: setDesigns(await adapters.database.filter('DesignConfiguration', { project_uuid: projectId }));
src/services/dashboardService.js:2: export const dashboardService = { async summary() { const [projects, sessions, customers] = await Promise.all([adapters.database.list('CoverProject'), adapters.database.list('MeasurementSession'), adapters.database.list('Customer')]); const count = (status) => projects.filter(p => p.record_state === 'active' && p.status === status).length; const projectCustomers = projects.reduce((a,p) => ({ ...a, [p.customer_uuid]: (a[p.customer_uuid] || 0) + 1 }), {}); return { projects, customers, active: projects.filter(p => p.record_state === 'active' && p.status !== 'Complete').length, measurements: sessions.filter(s => s.status !== 'Complete').length, clarification: count('Awaiting customer clarification'), selection: count('Designs awaiting selection'), review: count('Awaiting workshop review'), completed: projects.filter(p => p.status === 'Complete').slice(0,5), returning: Object.values(projectCustomers).filter(v => v > 1).length }; } };
src/services/designService.js:168: list: () => adapters.database.list('DesignConfiguration'),
src/services/designService.js:169: forProject: (project_uuid) => adapters.database.filter('DesignConfiguration', { project_uuid }, '-version'),
src/services/designService.js:171: const all = adapters.database.filter('DesignConfiguration', { project_uuid }, '-version');
src/services/designService.js:175: const all = await adapters.database.filter('DesignConfiguration', { project_uuid, is_current: true }, '-version', 1);
src/services/designService.js:178: get: async (uuid) => (await adapters.database.filter('DesignConfiguration', { uuid }, '-updated_date', 1))[0],
src/services/designService.js:180: const existing = await adapters.database.filter('DesignConfiguration', { project_uuid: data.project_uuid });
src/services/designService.js:182: const record = await adapters.database.create('DesignConfiguration', {
src/services/designService.js:190: await adapters.database.update('DesignConfiguration', d.id, { is_current: false, updated_by_name: actor });
src/services/designService.js:193: await auditService.record('design_created', 'DesignConfiguration', record.uuid, `Design revision v${version} created`, actor);
src/services/designService.js:199: const record = await adapters.database.update('DesignConfiguration', id, { ...editable, validation_status: validated.status, validation_issues: validated.issues, updated_by_name: actor });
src/services/designService.js:200: await auditService.record('design_updated', 'DesignConfiguration', uuid, 'Design configuration updated', actor);
src/services/designService.js:204: const existing = await adapters.database.filter('DesignConfiguration', { project_uuid });
src/services/designService.js:207: const record = await adapters.database.create('DesignConfiguration', {
src/services/designService.js:214: await adapters.database.update('DesignConfiguration', d.id, { is_current: false, updated_by_name: actor });
src/services/designService.js:217: await auditService.record('design_revision_saved', 'DesignConfiguration', record.uuid, `Design revision v${version} saved`, actor);
src/services/designService.js:229: const all = await adapters.database.filter('DesignConfiguration', { project_uuid: rev.project_uuid });
src/services/designService.js:231: await adapters.database.update('DesignConfiguration', d.id, { is_current: d.uuid === designUuid, updated_by_name: actor });
src/services/designService.js:233: await auditService.record('design_restored', 'DesignConfiguration', designUuid, `Design revision v${rev.version} restored as current`, actor);
src/services/designService.js:243: const record = await adapters.database.update('DesignConfiguration', rev.id, { approved_for_quote: true, concept_status: 'Approved for Quote', approved_design_uuid: uuid, updated_by_name: actor });
src/services/designService.js:244: await auditService.record('design_approved', 'DesignConfiguration', uuid, 'Design approved for quote (not CAD/print ready)', actor);
src/services/designService.js:256: const record = await adapters.database.update('DesignConfiguration', rev.id, { concept_status: status, updated_by_name: actor });
src/services/designService.js:257: await auditService.record('concept_status', 'DesignConfiguration', uuid, `Concept status set to ${status}`, actor);
src/services/designService.js:263: const record = await adapters.database.update('DesignConfiguration', rev.id, { customer_feedback: feedback, updated_by_name: actor });
src/services/designService.js:264: await auditService.record('concept_feedback', 'DesignConfiguration', uuid, 'Customer feedback recorded', actor);
src/services/designService.js:268: const existing = await adapters.database.filter('DesignConfiguration', { project_uuid });
src/services/designService.js:270: const record = await adapters.database.create('DesignConfiguration', {
src/services/designService.js:276: await auditService.record('concept_created', 'DesignConfiguration', record.uuid, `Concept "${data.concept_name || 'Untitled'}" created`, actor);
src/services/dimensionAnalysis.js:4: const verifiedSource = (d) => ['Manufacturer Verified Specification','Workshop Physical Measurement','3D Scan Measurement'].includes(d.source) && d.verification_status !== 'Conflict detected' && d.verification_status !== 'Superseded' && d.verification_status !== 'Unknown';
src/services/dimensionAnalysis.js:30: { label: 'Workshop measurements complete', done: envComplete.length, total: REQUIRED_ENVELOPE_KEYS.length },
src/services/dimensionAnalysis.js:31: { label: 'Measurement stations', done: stations.length, total: 1 },
src/services/dimensionAnalysis.js:62: const work = records.find(r => r.source === 'Workshop Physical Measurement' && r.value_mm != null);
src/services/dimensionAnalysis.js:69: conflicts.push({ key, type: 'Significant change between measurements', detail: `Previous ${prev.value_mm} mm vs latest ${last.value_mm} mm` });
src/services/dimensionAnalysis.js:90: if (dim) tasks.push({ key, name: dim[1], unit: dim[2], source: 'Workshop Physical Measurement', explanation: `Workshop measurement required — manufacturer spec does not provide this envelope value.` });
src/services/dimensionAnalysis.js:95: tasks.push({ key: '_movement', name: 'Record movement envelope', unit: 'text', source: 'Workshop Physical Measurement', explanation: `${complete.positionsMissing.length} movement positions still required for this joint.` });
src/services/dimensionAnalysis.js:97: tasks.push({ key: '_access', name: 'Record access points', unit: 'text', source: 'Workshop Physical Measurement', explanation: 'No access zones recorded yet.' });
src/services/dimensionAnalysis.js:99: tasks.push({ key: '_keepout', name: 'Record keep-out zones', unit: 'text', source: 'Workshop Physical Measurement', explanation: 'No keep-out zones recorded yet.' });
src/services/dimensionDefinitions.js:1: export const MEASUREMENT_SOURCES = [
src/services/dimensionDefinitions.js:3: 'Workshop Physical Measurement',
src/services/dimensionDefinitions.js:4: '3D Scan Measurement',
src/services/dimensionDefinitions.js:5: 'Customer-Reported Measurement',
src/services/dimensionDefinitions.js:6: 'Calculated Measurement',
src/services/dimensionDefinitions.js:7: 'Estimated Measurement',
src/services/dimensionDefinitions.js:10: export const VERIFIED_SOURCES = ['Manufacturer Verified Specification','Workshop Physical Measurement','3D Scan Measurement'];
src/services/dimensionDefinitions.js:12: export const CAD_BLOCKING_SOURCES = ['Estimated Measurement','Customer-Reported Measurement','Unknown'];
src/services/dimensionService.js:96: const session = await adapters.database.create('MeasurementSession', {
src/services/dimensionService.js:102: await auditService.record('session_created', 'MeasurementSession', session.uuid, `Created ${workflow} session`, actor);
src/services/fileStorageService.js:3: uploadMeasurementPhoto: (file, projectUuid) => adapters.files.upload(file, `/SHiREVault/SHiRELimbs/Measurements/${projectUuid}`),
src/services/measurementGeometryService.js:10: measurement: 'Measurement-driven visualisation — review required and not manufacturing geometry.',
src/services/measurementGeometryService.js:17: measurement: 'amber',
src/services/measurementGeometryService.js:24: * envelope-station measurements. Babylon never queries the DB directly —
src/services/measurementGeometryService.js:33: try { sessions = await base44.entities.MeasurementSession.filter({ project_uuid: projectUuid }); } catch (_) {}
src/services/measurementGeometryService.js:55: else if (withDims.length > 0) status = 'measurement';
src/services/measurementGeometryService.js:89: * Upsert a workshop cross-section station measurement (drives geometry).
src/services/measurementGeometryService.js:91: export async function saveStationMeasurement({ sessionUuid, componentUuid, station }) {
src/services/measurementService.js:3: export const measurementService = {
src/services/measurementService.js:4: sessions: () => adapters.database.list('MeasurementSession'),
src/services/measurementService.js:5: session: async (uuid) => (await adapters.database.filter('MeasurementSession', { uuid }, '-updated_date', 1))[0],
src/services/measurementService.js:6: definitions: (workflow) => adapters.database.filter('MeasurementDefinition', { workflow, active: true }, 'sequence'),
src/services/measurementService.js:7: values: (session_uuid) => adapters.database.filter('MeasurementValue', { session_uuid }),
src/services/measurementService.js:8: async save(session, definition, data, actor) { const existing = (await adapters.database.filter('MeasurementValue', { session_uuid: session.uuid, definition_uuid: definition.uuid }, '-updated_date', 1))[0]; const previous = (await adapters.database.filter('MeasurementValue', { definition_uuid: definition.uuid }, '-measured_date', 20)).find(v => v.session_uuid !== session.uuid && v.value_mm); const value_mm = data.entered_unit === 'cm' ? Number(data.value) * 10 : Number(data.value); const warnings = []; if (definition.unit === 'mm' && (value_mm < definition.minimum_value || value_mm > definition.maximum_value)) warnings.push(`Outside expected range ${definition.minimum_value}–${definition.maximum_value} mm.`); if (data.entered_unit === 'mm' && value_mm < definition.minimum_value && value_mm * 10 <= definition.maximum_value) warnings.push('Likely wrong unit: this value may have been entered in centimetres.'); if (previous && Math.abs(value_mm - previous.value_mm) / previous.value_mm > 0.2) warnings.push(`More than 20% different from a previous ${definition.name} record.`); const warning = warnings.length ? `${warnings.join(' ')} Manual review required.` : ''; const payload = { value_mm, entered_unit: data.entered_unit, confidence: data.confidence, measured_by: actor, measured_date: new Date().toISOString().slice(0,10), notes: data.notes, photo_url: data.photo_url || '', storage_destination: data.storage_destination || '', warning, updated_by_name: actor }; const saved = existing ? await adapters.database.update('MeasurementValue', existing.id, payload) : await adapters.database.create('MeasurementValue', { ...payload, uuid: newUuid('measure'), session_uuid: session.uuid, definition_uuid: definition.uuid, project_uuid: session.project_uuid, ...migrationFields(actor) }); await auditService.record('measurement_changed', 'MeasurementValue', saved.uuid, `Saved ${definition.name}`, actor, warning); return saved; },
src/services/measurementService.js:9: async skip(session, definition, reason, actor) { const saved = await adapters.database.create('MeasurementValue', { uuid: newUuid('measure'), session_uuid: session.uuid, definition_uuid: definition.uuid, project_uuid: session.project_uuid, entered_unit: 'text', skip_reason: reason, measured_by: actor, measured_date: new Date().toISOString().slice(0,10), ...migrationFields(actor) }); await auditService.record('measurement_skipped', 'MeasurementValue', saved.uuid, `Skipped ${definition.name}: ${reason}`, actor); return saved; },
src/services/measurementService.js:10: progress: (session, complete, total) => adapters.database.update('MeasurementSession', session.id, { progress_percent: Math.round((complete / total) * 100), status: complete >= total ? 'Complete' : 'In progress' }),
src/services/measurementService.js:11: pause: (session) => adapters.database.update('MeasurementSession', session.id, { status: 'Paused' }),
src/services/orderService.js:9: async create(data, actor) { const record = await adapters.database.create('Order', { ...data, uuid: newUuid('order'), order_number: `ORD-${Date.now().toString().slice(-6)}`, order_date: data.order_date || new Date().toISOString().slice(0, 10), production_status: data.production_status || 'Awaiting measurements', shipping_status: data.shipping_status || 'Not started', payment_status: data.payment_status || 'Unpaid', funding_approval_status: data.funding_approval_status || 'Not requested', invoice_status: data.invoice_status || 'Not issued', deposit: data.deposit || 0, balance: data.balance || (data.quote_amount || 0), data_origin: data.data_origin || 'Workshop Created', ...migrationFields(actor) }); await auditService.record('order_created', 'Order', record.uuid, `Created order ${record.order_number}`, actor); return record; },
src/services/orderService.js:14: async cancel(id, uuid, reason, actor) { await adapters.database.update('Order', id, { production_status: 'Awaiting measurements', cancel_reason: reason, record_state: 'archived', updated_by_name: actor }); return auditService.record('order_cancelled', 'Order', uuid, `Order cancelled: ${reason}`, actor); },
src/services/ossiguardService.js:4: export const OSSIGUARD_APPROVAL_STATUSES = ['Prototype', 'Measurement Required', 'Workshop Verified', 'CAD Verified', 'Approved Connector Revision', 'Superseded'];
src/services/ossiguardService.js:5: export const OSSIGUARD_GEOMETRY_STATUSES = ['Visual Reference', 'Measurement Required', 'Workshop Verified', 'CAD Verified', 'Approved Connector Revision', 'Superseded'];
src/services/ossiguardService.js:126: if (profile.geometry_status === 'Measurement Required') issues.push({ level: 'warning', text: 'Measurements still required' });
src/services/projectService.js:112: data.measurement_method?.includes('Manual')
src/services/projectService.js:113: || data.measurement_method?.includes(
src/services/projectService.js:135: 'MeasurementSession',
src/services/projectService.js:176: status: 'Awaiting measurements',
src/services/settingsRegistry.js:1: export const workshopStoragePaths = ['/SHiREVault/SHiRELimbs/Customers','/SHiREVault/SHiRELimbs/Projects','/SHiREVault/SHiRELimbs/Measurements','/SHiREVault/SHiRELimbs/Scans','/SHiREVault/SHiRELimbs/Components','/SHiREVault/SHiRELimbs/Designs','/SHiREVault/SHiRELimbs/Quotes','/SHiREVault/SHiRELimbs/Orders','/SHiREVault/SHiRELimbs/PrintFiles','/SHiREVault/SHiRELimbs/Reports','/SHiREVault/SHiRELimbs/SHiRELogos','/SHiREVault/SHiRELimbs/ArchivedProjects','/SHiREVault/SHiRELimbs/Backups'];
src/shire/ShireApp.jsx:23: import Measurements from '@/pages/Measurements';
src/shire/ShireApp.jsx:24: import MeasurementSession from '@/pages/MeasurementSession';
src/shire/ShireApp.jsx:50: <Route path="/new-cover" element={<NewCover />} />
src/shire/ShireApp.jsx:51: <Route path="/measurements" element={<Measurements />} />
src/shire/ShireApp.jsx:53: path="/measurements/:uuid"
src/shire/ShireApp.jsx:54: element={<MeasurementSession />}

------------------------------------------------------------
3. DESIGNCONFIGURATION CALL CONTEXT
------------------------------------------------------------

--- src/pages/builder/BuilderProjectDetail.jsx:12 ---
       2 | import { useParams, Link } from 'react-router-dom';
       3 | import { ArrowLeft, Ruler, Sparkles, Plug, Factory, ShieldCheck, Lock } from 'lucide-react';
       4 | import PageHeader from '@/components/workshop/PageHeader';
       5 | import LoadingPanel from '@/components/workshop/LoadingPanel';
       6 | import StatusPill from '@/components/workshop/StatusPill';
       7 | import { useAccount } from '@/lib/AccountContext';
       8 | import { adapters } from '@/services/serviceConfig';
       9 | 
      10 | const SECTIONS = [
      11 |   { key: 'measurements', label: 'Measurements', icon: Ruler, perm: 'measurements.record', entity: 'MeasurementSession', filter: 'project_uuid' },
>>    12 |   { key: 'design', label: 'Design Forge', icon: Sparkles, perm: 'design.use_forge', entity: 'DesignConfiguration', filter: 'project_uuid' },
      13 |   { key: 'ossiguard', label: 'Ossiguard', icon: Plug, perm: 'components.manage_ossiguard' },
      14 |   { key: 'manufacturing', label: 'Manufacturing', icon: Factory, perm: 'mfg.update_status', entity: 'ManufacturingJob', filter: 'project_uuid' },
      15 |   { key: 'validation', label: 'Validation', icon: ShieldCheck },
      16 | ];
      17 | 
      18 | export default function BuilderProjectDetail() {
      19 |   const { projectId } = useParams();
      20 |   const { account, hasPermission } = useAccount();
      21 |   const [project, setProject] = useState(null);
      22 |   const [data, setData] = useState({});
      23 | 
      24 |   useEffect(() => {
      25 |     if (!account) return;
      26 |     (async () => {

--- src/pages/portal/PortalDetail.jsx:11 ---
       1 | import { useEffect, useState } from 'react';
       2 | import { useParams, Link } from 'react-router-dom';
       3 | import { ArrowLeft, Lock } from 'lucide-react';
       4 | import PageHeader from '@/components/workshop/PageHeader';
       5 | import LoadingPanel from '@/components/workshop/LoadingPanel';
       6 | import StatusPill from '@/components/workshop/StatusPill';
       7 | import { useAccount } from '@/lib/AccountContext';
       8 | import { adapters } from '@/services/serviceConfig';
       9 | 
      10 | const ENTITY_MAP = {
>>    11 |   quotes: 'Quote', orders: 'Order', 'completed-covers': 'CompletedCover', designs: 'DesignConfiguration',
      12 | };
      13 | const FIELDS = {
      14 |   Quote: ['quote_number', 'amount', 'approval_status', 'sent_date', 'expiry_date', 'funding_type'],
      15 |   Order: ['order_number', 'production_status', 'payment_status', 'funding_approval_status', 'due_date'],
      16 |   CompletedCover: ['cover_reference', 'material', 'main_colour', 'inspection_result', 'fit_review_result', 'completion_date', 'delivery_date'],
      17 |   DesignConfiguration: ['concept_name', 'design_category', 'main_colour', 'accent_colour', 'finish', 'concept_status'],
      18 | };
      19 | 
      20 | export default function PortalDetail({ section }) {
      21 |   const { [`${section === 'completed-covers' ? 'coverId' : section === 'quotes' ? 'quoteId' : section === 'orders' ? 'orderId' : 'designId'}`]: id } = useParams();
      22 |   const { account } = useAccount();
      23 |   const [item, setItem] = useState(null);
      24 |   const entity = ENTITY_MAP[section];
      25 | 

--- src/pages/portal/PortalDetail.jsx:17 ---
       7 | import { useAccount } from '@/lib/AccountContext';
       8 | import { adapters } from '@/services/serviceConfig';
       9 | 
      10 | const ENTITY_MAP = {
      11 |   quotes: 'Quote', orders: 'Order', 'completed-covers': 'CompletedCover', designs: 'DesignConfiguration',
      12 | };
      13 | const FIELDS = {
      14 |   Quote: ['quote_number', 'amount', 'approval_status', 'sent_date', 'expiry_date', 'funding_type'],
      15 |   Order: ['order_number', 'production_status', 'payment_status', 'funding_approval_status', 'due_date'],
      16 |   CompletedCover: ['cover_reference', 'material', 'main_colour', 'inspection_result', 'fit_review_result', 'completion_date', 'delivery_date'],
>>    17 |   DesignConfiguration: ['concept_name', 'design_category', 'main_colour', 'accent_colour', 'finish', 'concept_status'],
      18 | };
      19 | 
      20 | export default function PortalDetail({ section }) {
      21 |   const { [`${section === 'completed-covers' ? 'coverId' : section === 'quotes' ? 'quoteId' : section === 'orders' ? 'orderId' : 'designId'}`]: id } = useParams();
      22 |   const { account } = useAccount();
      23 |   const [item, setItem] = useState(null);
      24 |   const entity = ENTITY_MAP[section];
      25 | 
      26 |   useEffect(() => {
      27 |     if (!account?.customer_uuid || !entity || !id) { setItem(null); return; }
      28 |     adapters.database.filter(entity, { uuid: id }).then(r => setItem(r[0]));
      29 |   }, [id, account, entity]);
      30 | 
      31 |   if (!account) return <LoadingPanel label="Loading" />;

--- src/pages/portal/PortalProject.jsx:27 ---
      17 |   const [quote, setQuote] = useState(null);
      18 |   const [toast, setToast] = useState('');
      19 | 
      20 |   useEffect(() => {
      21 |     if (!account?.customer_uuid) return;
      22 |     (async () => {
      23 |       const ps = await adapters.database.filter('CoverProject', { uuid: projectId });
      24 |       const p = ps[0];
      25 |       setProject(p);
      26 |       if (p && p.customer_uuid === account.customer_uuid) {
>>    27 |         setDesigns(await adapters.database.filter('DesignConfiguration', { project_uuid: projectId }));
      28 |         if (p.uuid) {
      29 |           const qs = await adapters.database.filter('Quote', { project_uuid: projectId });
      30 |           setQuote(qs[0] || null);
      31 |         }
      32 |       }
      33 |     })();
      34 |   }, [projectId, account]);
      35 | 
      36 |   if (!account) return <LoadingPanel label="Loading" />;
      37 |   if (!project) return <LoadingPanel label="Loading request" />;
      38 | 
      39 |   if (project.customer_uuid !== account.customer_uuid) {
      40 |     return (
      41 |       <div className="panel mx-auto mt-12 max-w-lg p-8 text-center">

--- src/pages/portal/PortalProject.jsx:52 ---
      42 |         <h2 className="text-lg font-semibold text-white">This request is not yours</h2>
      43 |         <p className="mt-2 text-sm text-shire-text-secondary">You can only view your own cover requests.</p>
      44 |         <Link to="/portal" className="btn-primary mt-4">Back to my portal</Link>
      45 |       </div>
      46 |     );
      47 |   }
      48 | 
      49 |   const releasedDesigns = (designs || []).filter(d => d.concept_status === 'Sent to Customer' || d.concept_status === 'Customer Preferred' || d.concept_status === 'Approved for Quote');
      50 | 
      51 |   const preferDesign = async (d) => {
>>    52 |     await adapters.database.update('DesignConfiguration', d.id, { concept_status: 'Customer Preferred', customer_feedback: (d.customer_feedback || '') + ' [Marked preferred]' });
      53 |     auditService.record('design_preference', 'DesignConfiguration', d.uuid, 'Customer marked design as preferred', account.display_name);
      54 |     setToast('Preference saved. This confirms visual direction only — it does not mean CAD, manufacturing or NDIS approval is complete.');
      55 |     setTimeout(() => setToast(''), 5000);
      56 |     setDesigns(await adapters.database.filter('DesignConfiguration', { project_uuid: projectId }));
      57 |   };
      58 | 
      59 |   const approveForQuote = async (d) => {
      60 |     await adapters.database.update('DesignConfiguration', d.id, { concept_status: 'Approved for Quote', approved_for_quote: true });
      61 |     auditService.record('design_approved', 'DesignConfiguration', d.uuid, 'Customer approved design for quote', account.display_name);
      62 |     setToast('Design approved for quote. A quote will be prepared for you.');
      63 |     setTimeout(() => setToast(''), 4000);
      64 |     setDesigns(await adapters.database.filter('DesignConfiguration', { project_uuid: projectId }));
      65 |   };
      66 | 

--- src/pages/portal/PortalProject.jsx:53 ---
      43 |         <p className="mt-2 text-sm text-shire-text-secondary">You can only view your own cover requests.</p>
      44 |         <Link to="/portal" className="btn-primary mt-4">Back to my portal</Link>
      45 |       </div>
      46 |     );
      47 |   }
      48 | 
      49 |   const releasedDesigns = (designs || []).filter(d => d.concept_status === 'Sent to Customer' || d.concept_status === 'Customer Preferred' || d.concept_status === 'Approved for Quote');
      50 | 
      51 |   const preferDesign = async (d) => {
      52 |     await adapters.database.update('DesignConfiguration', d.id, { concept_status: 'Customer Preferred', customer_feedback: (d.customer_feedback || '') + ' [Marked preferred]' });
>>    53 |     auditService.record('design_preference', 'DesignConfiguration', d.uuid, 'Customer marked design as preferred', account.display_name);
      54 |     setToast('Preference saved. This confirms visual direction only — it does not mean CAD, manufacturing or NDIS approval is complete.');
      55 |     setTimeout(() => setToast(''), 5000);
      56 |     setDesigns(await adapters.database.filter('DesignConfiguration', { project_uuid: projectId }));
      57 |   };
      58 | 
      59 |   const approveForQuote = async (d) => {
      60 |     await adapters.database.update('DesignConfiguration', d.id, { concept_status: 'Approved for Quote', approved_for_quote: true });
      61 |     auditService.record('design_approved', 'DesignConfiguration', d.uuid, 'Customer approved design for quote', account.display_name);
      62 |     setToast('Design approved for quote. A quote will be prepared for you.');
      63 |     setTimeout(() => setToast(''), 4000);
      64 |     setDesigns(await adapters.database.filter('DesignConfiguration', { project_uuid: projectId }));
      65 |   };
      66 | 
      67 |   return (

--- src/pages/portal/PortalProject.jsx:56 ---
      46 |     );
      47 |   }
      48 | 
      49 |   const releasedDesigns = (designs || []).filter(d => d.concept_status === 'Sent to Customer' || d.concept_status === 'Customer Preferred' || d.concept_status === 'Approved for Quote');
      50 | 
      51 |   const preferDesign = async (d) => {
      52 |     await adapters.database.update('DesignConfiguration', d.id, { concept_status: 'Customer Preferred', customer_feedback: (d.customer_feedback || '') + ' [Marked preferred]' });
      53 |     auditService.record('design_preference', 'DesignConfiguration', d.uuid, 'Customer marked design as preferred', account.display_name);
      54 |     setToast('Preference saved. This confirms visual direction only — it does not mean CAD, manufacturing or NDIS approval is complete.');
      55 |     setTimeout(() => setToast(''), 5000);
>>    56 |     setDesigns(await adapters.database.filter('DesignConfiguration', { project_uuid: projectId }));
      57 |   };
      58 | 
      59 |   const approveForQuote = async (d) => {
      60 |     await adapters.database.update('DesignConfiguration', d.id, { concept_status: 'Approved for Quote', approved_for_quote: true });
      61 |     auditService.record('design_approved', 'DesignConfiguration', d.uuid, 'Customer approved design for quote', account.display_name);
      62 |     setToast('Design approved for quote. A quote will be prepared for you.');
      63 |     setTimeout(() => setToast(''), 4000);
      64 |     setDesigns(await adapters.database.filter('DesignConfiguration', { project_uuid: projectId }));
      65 |   };
      66 | 
      67 |   return (
      68 |     <>
      69 |       <Link to="/portal" className="mb-4 inline-flex items-center gap-1 text-sm text-slate-400 hover:text-violet-300"><ArrowLeft className="h-4 w-4" />Back to my portal</Link>
      70 |       <PageHeader eyebrow="My Request" title={`Request ${project.project_id}`} description="Your cover request summary and design concepts released to you." />

--- src/pages/portal/PortalProject.jsx:60 ---
      50 | 
      51 |   const preferDesign = async (d) => {
      52 |     await adapters.database.update('DesignConfiguration', d.id, { concept_status: 'Customer Preferred', customer_feedback: (d.customer_feedback || '') + ' [Marked preferred]' });
      53 |     auditService.record('design_preference', 'DesignConfiguration', d.uuid, 'Customer marked design as preferred', account.display_name);
      54 |     setToast('Preference saved. This confirms visual direction only — it does not mean CAD, manufacturing or NDIS approval is complete.');
      55 |     setTimeout(() => setToast(''), 5000);
      56 |     setDesigns(await adapters.database.filter('DesignConfiguration', { project_uuid: projectId }));
      57 |   };
      58 | 
      59 |   const approveForQuote = async (d) => {
>>    60 |     await adapters.database.update('DesignConfiguration', d.id, { concept_status: 'Approved for Quote', approved_for_quote: true });
      61 |     auditService.record('design_approved', 'DesignConfiguration', d.uuid, 'Customer approved design for quote', account.display_name);
      62 |     setToast('Design approved for quote. A quote will be prepared for you.');
      63 |     setTimeout(() => setToast(''), 4000);
      64 |     setDesigns(await adapters.database.filter('DesignConfiguration', { project_uuid: projectId }));
      65 |   };
      66 | 
      67 |   return (
      68 |     <>
      69 |       <Link to="/portal" className="mb-4 inline-flex items-center gap-1 text-sm text-slate-400 hover:text-violet-300"><ArrowLeft className="h-4 w-4" />Back to my portal</Link>
      70 |       <PageHeader eyebrow="My Request" title={`Request ${project.project_id}`} description="Your cover request summary and design concepts released to you." />
      71 | 
      72 |       {toast && <div className="mb-4 rounded-lg border border-shire-purple/40 bg-shire-purple/10 p-3 text-sm text-violet-200">{toast}</div>}
      73 | 
      74 |       <div className="grid gap-6 lg:grid-cols-2">

--- src/pages/portal/PortalProject.jsx:61 ---
      51 |   const preferDesign = async (d) => {
      52 |     await adapters.database.update('DesignConfiguration', d.id, { concept_status: 'Customer Preferred', customer_feedback: (d.customer_feedback || '') + ' [Marked preferred]' });
      53 |     auditService.record('design_preference', 'DesignConfiguration', d.uuid, 'Customer marked design as preferred', account.display_name);
      54 |     setToast('Preference saved. This confirms visual direction only — it does not mean CAD, manufacturing or NDIS approval is complete.');
      55 |     setTimeout(() => setToast(''), 5000);
      56 |     setDesigns(await adapters.database.filter('DesignConfiguration', { project_uuid: projectId }));
      57 |   };
      58 | 
      59 |   const approveForQuote = async (d) => {
      60 |     await adapters.database.update('DesignConfiguration', d.id, { concept_status: 'Approved for Quote', approved_for_quote: true });
>>    61 |     auditService.record('design_approved', 'DesignConfiguration', d.uuid, 'Customer approved design for quote', account.display_name);
      62 |     setToast('Design approved for quote. A quote will be prepared for you.');
      63 |     setTimeout(() => setToast(''), 4000);
      64 |     setDesigns(await adapters.database.filter('DesignConfiguration', { project_uuid: projectId }));
      65 |   };
      66 | 
      67 |   return (
      68 |     <>
      69 |       <Link to="/portal" className="mb-4 inline-flex items-center gap-1 text-sm text-slate-400 hover:text-violet-300"><ArrowLeft className="h-4 w-4" />Back to my portal</Link>
      70 |       <PageHeader eyebrow="My Request" title={`Request ${project.project_id}`} description="Your cover request summary and design concepts released to you." />
      71 | 
      72 |       {toast && <div className="mb-4 rounded-lg border border-shire-purple/40 bg-shire-purple/10 p-3 text-sm text-violet-200">{toast}</div>}
      73 | 
      74 |       <div className="grid gap-6 lg:grid-cols-2">
      75 |         <section className="panel p-5">

--- src/pages/portal/PortalProject.jsx:64 ---
      54 |     setToast('Preference saved. This confirms visual direction only — it does not mean CAD, manufacturing or NDIS approval is complete.');
      55 |     setTimeout(() => setToast(''), 5000);
      56 |     setDesigns(await adapters.database.filter('DesignConfiguration', { project_uuid: projectId }));
      57 |   };
      58 | 
      59 |   const approveForQuote = async (d) => {
      60 |     await adapters.database.update('DesignConfiguration', d.id, { concept_status: 'Approved for Quote', approved_for_quote: true });
      61 |     auditService.record('design_approved', 'DesignConfiguration', d.uuid, 'Customer approved design for quote', account.display_name);
      62 |     setToast('Design approved for quote. A quote will be prepared for you.');
      63 |     setTimeout(() => setToast(''), 4000);
>>    64 |     setDesigns(await adapters.database.filter('DesignConfiguration', { project_uuid: projectId }));
      65 |   };
      66 | 
      67 |   return (
      68 |     <>
      69 |       <Link to="/portal" className="mb-4 inline-flex items-center gap-1 text-sm text-slate-400 hover:text-violet-300"><ArrowLeft className="h-4 w-4" />Back to my portal</Link>
      70 |       <PageHeader eyebrow="My Request" title={`Request ${project.project_id}`} description="Your cover request summary and design concepts released to you." />
      71 | 
      72 |       {toast && <div className="mb-4 rounded-lg border border-shire-purple/40 bg-shire-purple/10 p-3 text-sm text-violet-200">{toast}</div>}
      73 | 
      74 |       <div className="grid gap-6 lg:grid-cols-2">
      75 |         <section className="panel p-5">
      76 |           <h2 className="section-title">Request Summary</h2>
      77 |           <dl className="space-y-2 text-sm">
      78 |             <div className="flex justify-between"><dt className="text-shire-text-muted">Status</dt><dd><StatusPill tone="cyan">{project.status}</StatusPill></dd></div>

--- src/services/designService.js:168 ---
     158 |   if (config.detail_access_door_styling && connectorSide === 'lateral') {
     159 |     issues.push({ level: 'warning', text: 'Access-door styling near connector — verify fastener access and release path remain unobstructed' });
     160 |   }
     161 |   if (ossiguard.panel_opening_required && config.pattern_style && config.pattern_style !== 'none') {
     162 |     issues.push({ level: 'warning', text: 'Panel opening required for Ossiguard — verify pattern does not block the opening' });
     163 |   }
     164 |   return issues;
     165 | }
     166 | 
     167 | export const designService = {
>>   168 |   list: () => adapters.database.list('DesignConfiguration'),
     169 |   forProject: (project_uuid) => adapters.database.filter('DesignConfiguration', { project_uuid }, '-version'),
     170 |   getConcepts: (project_uuid) => {
     171 |     const all = adapters.database.filter('DesignConfiguration', { project_uuid }, '-version');
     172 |     return all;
     173 |   },
     174 |   getCurrent: async (project_uuid) => {
     175 |     const all = await adapters.database.filter('DesignConfiguration', { project_uuid, is_current: true }, '-version', 1);
     176 |     return all[0] || null;
     177 |   },
     178 |   get: async (uuid) => (await adapters.database.filter('DesignConfiguration', { uuid }, '-updated_date', 1))[0],
     179 |   async create(data, actor) {
     180 |     const existing = await adapters.database.filter('DesignConfiguration', { project_uuid: data.project_uuid });
     181 |     const version = (existing.length ? Math.max(...existing.map((d) => d.version || 0)) : 0) + 1;
     182 |     const record = await adapters.database.create('DesignConfiguration', {

--- src/services/designService.js:169 ---
     159 |     issues.push({ level: 'warning', text: 'Access-door styling near connector — verify fastener access and release path remain unobstructed' });
     160 |   }
     161 |   if (ossiguard.panel_opening_required && config.pattern_style && config.pattern_style !== 'none') {
     162 |     issues.push({ level: 'warning', text: 'Panel opening required for Ossiguard — verify pattern does not block the opening' });
     163 |   }
     164 |   return issues;
     165 | }
     166 | 
     167 | export const designService = {
     168 |   list: () => adapters.database.list('DesignConfiguration'),
>>   169 |   forProject: (project_uuid) => adapters.database.filter('DesignConfiguration', { project_uuid }, '-version'),
     170 |   getConcepts: (project_uuid) => {
     171 |     const all = adapters.database.filter('DesignConfiguration', { project_uuid }, '-version');
     172 |     return all;
     173 |   },
     174 |   getCurrent: async (project_uuid) => {
     175 |     const all = await adapters.database.filter('DesignConfiguration', { project_uuid, is_current: true }, '-version', 1);
     176 |     return all[0] || null;
     177 |   },
     178 |   get: async (uuid) => (await adapters.database.filter('DesignConfiguration', { uuid }, '-updated_date', 1))[0],
     179 |   async create(data, actor) {
     180 |     const existing = await adapters.database.filter('DesignConfiguration', { project_uuid: data.project_uuid });
     181 |     const version = (existing.length ? Math.max(...existing.map((d) => d.version || 0)) : 0) + 1;
     182 |     const record = await adapters.database.create('DesignConfiguration', {
     183 |       ...data, uuid: newUuid('design'), version, is_current: true,

--- src/services/designService.js:171 ---
     161 |   if (ossiguard.panel_opening_required && config.pattern_style && config.pattern_style !== 'none') {
     162 |     issues.push({ level: 'warning', text: 'Panel opening required for Ossiguard — verify pattern does not block the opening' });
     163 |   }
     164 |   return issues;
     165 | }
     166 | 
     167 | export const designService = {
     168 |   list: () => adapters.database.list('DesignConfiguration'),
     169 |   forProject: (project_uuid) => adapters.database.filter('DesignConfiguration', { project_uuid }, '-version'),
     170 |   getConcepts: (project_uuid) => {
>>   171 |     const all = adapters.database.filter('DesignConfiguration', { project_uuid }, '-version');
     172 |     return all;
     173 |   },
     174 |   getCurrent: async (project_uuid) => {
     175 |     const all = await adapters.database.filter('DesignConfiguration', { project_uuid, is_current: true }, '-version', 1);
     176 |     return all[0] || null;
     177 |   },
     178 |   get: async (uuid) => (await adapters.database.filter('DesignConfiguration', { uuid }, '-updated_date', 1))[0],
     179 |   async create(data, actor) {
     180 |     const existing = await adapters.database.filter('DesignConfiguration', { project_uuid: data.project_uuid });
     181 |     const version = (existing.length ? Math.max(...existing.map((d) => d.version || 0)) : 0) + 1;
     182 |     const record = await adapters.database.create('DesignConfiguration', {
     183 |       ...data, uuid: newUuid('design'), version, is_current: true,
     184 |       validation_status: data.validation_status || 'Warning',
     185 |       validation_issues: data.validation_issues || [],

--- src/services/designService.js:175 ---
     165 | }
     166 | 
     167 | export const designService = {
     168 |   list: () => adapters.database.list('DesignConfiguration'),
     169 |   forProject: (project_uuid) => adapters.database.filter('DesignConfiguration', { project_uuid }, '-version'),
     170 |   getConcepts: (project_uuid) => {
     171 |     const all = adapters.database.filter('DesignConfiguration', { project_uuid }, '-version');
     172 |     return all;
     173 |   },
     174 |   getCurrent: async (project_uuid) => {
>>   175 |     const all = await adapters.database.filter('DesignConfiguration', { project_uuid, is_current: true }, '-version', 1);
     176 |     return all[0] || null;
     177 |   },
     178 |   get: async (uuid) => (await adapters.database.filter('DesignConfiguration', { uuid }, '-updated_date', 1))[0],
     179 |   async create(data, actor) {
     180 |     const existing = await adapters.database.filter('DesignConfiguration', { project_uuid: data.project_uuid });
     181 |     const version = (existing.length ? Math.max(...existing.map((d) => d.version || 0)) : 0) + 1;
     182 |     const record = await adapters.database.create('DesignConfiguration', {
     183 |       ...data, uuid: newUuid('design'), version, is_current: true,
     184 |       validation_status: data.validation_status || 'Warning',
     185 |       validation_issues: data.validation_issues || [],
     186 |       ...migrationFields(actor),
     187 |     });
     188 |     for (const d of existing) {
     189 |       if (d.id !== record.id && d.is_current) {

--- src/services/designService.js:178 ---
     168 |   list: () => adapters.database.list('DesignConfiguration'),
     169 |   forProject: (project_uuid) => adapters.database.filter('DesignConfiguration', { project_uuid }, '-version'),
     170 |   getConcepts: (project_uuid) => {
     171 |     const all = adapters.database.filter('DesignConfiguration', { project_uuid }, '-version');
     172 |     return all;
     173 |   },
     174 |   getCurrent: async (project_uuid) => {
     175 |     const all = await adapters.database.filter('DesignConfiguration', { project_uuid, is_current: true }, '-version', 1);
     176 |     return all[0] || null;
     177 |   },
>>   178 |   get: async (uuid) => (await adapters.database.filter('DesignConfiguration', { uuid }, '-updated_date', 1))[0],
     179 |   async create(data, actor) {
     180 |     const existing = await adapters.database.filter('DesignConfiguration', { project_uuid: data.project_uuid });
     181 |     const version = (existing.length ? Math.max(...existing.map((d) => d.version || 0)) : 0) + 1;
     182 |     const record = await adapters.database.create('DesignConfiguration', {
     183 |       ...data, uuid: newUuid('design'), version, is_current: true,
     184 |       validation_status: data.validation_status || 'Warning',
     185 |       validation_issues: data.validation_issues || [],
     186 |       ...migrationFields(actor),
     187 |     });
     188 |     for (const d of existing) {
     189 |       if (d.id !== record.id && d.is_current) {
     190 |         await adapters.database.update('DesignConfiguration', d.id, { is_current: false, updated_by_name: actor });
     191 |       }
     192 |     }

--- src/services/designService.js:180 ---
     170 |   getConcepts: (project_uuid) => {
     171 |     const all = adapters.database.filter('DesignConfiguration', { project_uuid }, '-version');
     172 |     return all;
     173 |   },
     174 |   getCurrent: async (project_uuid) => {
     175 |     const all = await adapters.database.filter('DesignConfiguration', { project_uuid, is_current: true }, '-version', 1);
     176 |     return all[0] || null;
     177 |   },
     178 |   get: async (uuid) => (await adapters.database.filter('DesignConfiguration', { uuid }, '-updated_date', 1))[0],
     179 |   async create(data, actor) {
>>   180 |     const existing = await adapters.database.filter('DesignConfiguration', { project_uuid: data.project_uuid });
     181 |     const version = (existing.length ? Math.max(...existing.map((d) => d.version || 0)) : 0) + 1;
     182 |     const record = await adapters.database.create('DesignConfiguration', {
     183 |       ...data, uuid: newUuid('design'), version, is_current: true,
     184 |       validation_status: data.validation_status || 'Warning',
     185 |       validation_issues: data.validation_issues || [],
     186 |       ...migrationFields(actor),
     187 |     });
     188 |     for (const d of existing) {
     189 |       if (d.id !== record.id && d.is_current) {
     190 |         await adapters.database.update('DesignConfiguration', d.id, { is_current: false, updated_by_name: actor });
     191 |       }
     192 |     }
     193 |     await auditService.record('design_created', 'DesignConfiguration', record.uuid, `Design revision v${version} created`, actor);
     194 |     return record;

--- src/services/designService.js:182 ---
     172 |     return all;
     173 |   },
     174 |   getCurrent: async (project_uuid) => {
     175 |     const all = await adapters.database.filter('DesignConfiguration', { project_uuid, is_current: true }, '-version', 1);
     176 |     return all[0] || null;
     177 |   },
     178 |   get: async (uuid) => (await adapters.database.filter('DesignConfiguration', { uuid }, '-updated_date', 1))[0],
     179 |   async create(data, actor) {
     180 |     const existing = await adapters.database.filter('DesignConfiguration', { project_uuid: data.project_uuid });
     181 |     const version = (existing.length ? Math.max(...existing.map((d) => d.version || 0)) : 0) + 1;
>>   182 |     const record = await adapters.database.create('DesignConfiguration', {
     183 |       ...data, uuid: newUuid('design'), version, is_current: true,
     184 |       validation_status: data.validation_status || 'Warning',
     185 |       validation_issues: data.validation_issues || [],
     186 |       ...migrationFields(actor),
     187 |     });
     188 |     for (const d of existing) {
     189 |       if (d.id !== record.id && d.is_current) {
     190 |         await adapters.database.update('DesignConfiguration', d.id, { is_current: false, updated_by_name: actor });
     191 |       }
     192 |     }
     193 |     await auditService.record('design_created', 'DesignConfiguration', record.uuid, `Design revision v${version} created`, actor);
     194 |     return record;
     195 |   },
     196 |   async update(id, uuid, data, actor) {

--- src/services/designService.js:190 ---
     180 |     const existing = await adapters.database.filter('DesignConfiguration', { project_uuid: data.project_uuid });
     181 |     const version = (existing.length ? Math.max(...existing.map((d) => d.version || 0)) : 0) + 1;
     182 |     const record = await adapters.database.create('DesignConfiguration', {
     183 |       ...data, uuid: newUuid('design'), version, is_current: true,
     184 |       validation_status: data.validation_status || 'Warning',
     185 |       validation_issues: data.validation_issues || [],
     186 |       ...migrationFields(actor),
     187 |     });
     188 |     for (const d of existing) {
     189 |       if (d.id !== record.id && d.is_current) {
>>   190 |         await adapters.database.update('DesignConfiguration', d.id, { is_current: false, updated_by_name: actor });
     191 |       }
     192 |     }
     193 |     await auditService.record('design_created', 'DesignConfiguration', record.uuid, `Design revision v${version} created`, actor);
     194 |     return record;
     195 |   },
     196 |   async update(id, uuid, data, actor) {
     197 |     const { id: _id, created_date, updated_date, created_by_id, ...editable } = data;
     198 |     const validated = designService.validate({ ...editable });
     199 |     const record = await adapters.database.update('DesignConfiguration', id, { ...editable, validation_status: validated.status, validation_issues: validated.issues, updated_by_name: actor });
     200 |     await auditService.record('design_updated', 'DesignConfiguration', uuid, 'Design configuration updated', actor);
     201 |     return record;
     202 |   },
     203 |   async saveRevision(project_uuid, data, actor) {
     204 |     const existing = await adapters.database.filter('DesignConfiguration', { project_uuid });

--- src/services/designService.js:193 ---
     183 |       ...data, uuid: newUuid('design'), version, is_current: true,
     184 |       validation_status: data.validation_status || 'Warning',
     185 |       validation_issues: data.validation_issues || [],
     186 |       ...migrationFields(actor),
     187 |     });
     188 |     for (const d of existing) {
     189 |       if (d.id !== record.id && d.is_current) {
     190 |         await adapters.database.update('DesignConfiguration', d.id, { is_current: false, updated_by_name: actor });
     191 |       }
     192 |     }
>>   193 |     await auditService.record('design_created', 'DesignConfiguration', record.uuid, `Design revision v${version} created`, actor);
     194 |     return record;
     195 |   },
     196 |   async update(id, uuid, data, actor) {
     197 |     const { id: _id, created_date, updated_date, created_by_id, ...editable } = data;
     198 |     const validated = designService.validate({ ...editable });
     199 |     const record = await adapters.database.update('DesignConfiguration', id, { ...editable, validation_status: validated.status, validation_issues: validated.issues, updated_by_name: actor });
     200 |     await auditService.record('design_updated', 'DesignConfiguration', uuid, 'Design configuration updated', actor);
     201 |     return record;
     202 |   },
     203 |   async saveRevision(project_uuid, data, actor) {
     204 |     const existing = await adapters.database.filter('DesignConfiguration', { project_uuid });
     205 |     const version = (existing.length ? Math.max(...existing.map((d) => d.version || 0)) : 0) + 1;
     206 |     const validated = designService.validate(data);
     207 |     const record = await adapters.database.create('DesignConfiguration', {

--- src/services/designService.js:199 ---
     189 |       if (d.id !== record.id && d.is_current) {
     190 |         await adapters.database.update('DesignConfiguration', d.id, { is_current: false, updated_by_name: actor });
     191 |       }
     192 |     }
     193 |     await auditService.record('design_created', 'DesignConfiguration', record.uuid, `Design revision v${version} created`, actor);
     194 |     return record;
     195 |   },
     196 |   async update(id, uuid, data, actor) {
     197 |     const { id: _id, created_date, updated_date, created_by_id, ...editable } = data;
     198 |     const validated = designService.validate({ ...editable });
>>   199 |     const record = await adapters.database.update('DesignConfiguration', id, { ...editable, validation_status: validated.status, validation_issues: validated.issues, updated_by_name: actor });
     200 |     await auditService.record('design_updated', 'DesignConfiguration', uuid, 'Design configuration updated', actor);
     201 |     return record;
     202 |   },
     203 |   async saveRevision(project_uuid, data, actor) {
     204 |     const existing = await adapters.database.filter('DesignConfiguration', { project_uuid });
     205 |     const version = (existing.length ? Math.max(...existing.map((d) => d.version || 0)) : 0) + 1;
     206 |     const validated = designService.validate(data);
     207 |     const record = await adapters.database.create('DesignConfiguration', {
     208 |       ...data, uuid: newUuid('design'), project_uuid, version, is_current: true,
     209 |       validation_status: validated.status, validation_issues: validated.issues,
     210 |       ...migrationFields(actor),
     211 |     });
     212 |     for (const d of existing) {
     213 |       if (d.id !== record.id && d.is_current) {

--- src/services/designService.js:200 ---
     190 |         await adapters.database.update('DesignConfiguration', d.id, { is_current: false, updated_by_name: actor });
     191 |       }
     192 |     }
     193 |     await auditService.record('design_created', 'DesignConfiguration', record.uuid, `Design revision v${version} created`, actor);
     194 |     return record;
     195 |   },
     196 |   async update(id, uuid, data, actor) {
     197 |     const { id: _id, created_date, updated_date, created_by_id, ...editable } = data;
     198 |     const validated = designService.validate({ ...editable });
     199 |     const record = await adapters.database.update('DesignConfiguration', id, { ...editable, validation_status: validated.status, validation_issues: validated.issues, updated_by_name: actor });
>>   200 |     await auditService.record('design_updated', 'DesignConfiguration', uuid, 'Design configuration updated', actor);
     201 |     return record;
     202 |   },
     203 |   async saveRevision(project_uuid, data, actor) {
     204 |     const existing = await adapters.database.filter('DesignConfiguration', { project_uuid });
     205 |     const version = (existing.length ? Math.max(...existing.map((d) => d.version || 0)) : 0) + 1;
     206 |     const validated = designService.validate(data);
     207 |     const record = await adapters.database.create('DesignConfiguration', {
     208 |       ...data, uuid: newUuid('design'), project_uuid, version, is_current: true,
     209 |       validation_status: validated.status, validation_issues: validated.issues,
     210 |       ...migrationFields(actor),
     211 |     });
     212 |     for (const d of existing) {
     213 |       if (d.id !== record.id && d.is_current) {
     214 |         await adapters.database.update('DesignConfiguration', d.id, { is_current: false, updated_by_name: actor });

--- src/services/designService.js:204 ---
     194 |     return record;
     195 |   },
     196 |   async update(id, uuid, data, actor) {
     197 |     const { id: _id, created_date, updated_date, created_by_id, ...editable } = data;
     198 |     const validated = designService.validate({ ...editable });
     199 |     const record = await adapters.database.update('DesignConfiguration', id, { ...editable, validation_status: validated.status, validation_issues: validated.issues, updated_by_name: actor });
     200 |     await auditService.record('design_updated', 'DesignConfiguration', uuid, 'Design configuration updated', actor);
     201 |     return record;
     202 |   },
     203 |   async saveRevision(project_uuid, data, actor) {
>>   204 |     const existing = await adapters.database.filter('DesignConfiguration', { project_uuid });
     205 |     const version = (existing.length ? Math.max(...existing.map((d) => d.version || 0)) : 0) + 1;
     206 |     const validated = designService.validate(data);
     207 |     const record = await adapters.database.create('DesignConfiguration', {
     208 |       ...data, uuid: newUuid('design'), project_uuid, version, is_current: true,
     209 |       validation_status: validated.status, validation_issues: validated.issues,
     210 |       ...migrationFields(actor),
     211 |     });
     212 |     for (const d of existing) {
     213 |       if (d.id !== record.id && d.is_current) {
     214 |         await adapters.database.update('DesignConfiguration', d.id, { is_current: false, updated_by_name: actor });
     215 |       }
     216 |     }
     217 |     await auditService.record('design_revision_saved', 'DesignConfiguration', record.uuid, `Design revision v${version} saved`, actor);
     218 |     return record;

--- src/services/designService.js:207 ---
     197 |     const { id: _id, created_date, updated_date, created_by_id, ...editable } = data;
     198 |     const validated = designService.validate({ ...editable });
     199 |     const record = await adapters.database.update('DesignConfiguration', id, { ...editable, validation_status: validated.status, validation_issues: validated.issues, updated_by_name: actor });
     200 |     await auditService.record('design_updated', 'DesignConfiguration', uuid, 'Design configuration updated', actor);
     201 |     return record;
     202 |   },
     203 |   async saveRevision(project_uuid, data, actor) {
     204 |     const existing = await adapters.database.filter('DesignConfiguration', { project_uuid });
     205 |     const version = (existing.length ? Math.max(...existing.map((d) => d.version || 0)) : 0) + 1;
     206 |     const validated = designService.validate(data);
>>   207 |     const record = await adapters.database.create('DesignConfiguration', {
     208 |       ...data, uuid: newUuid('design'), project_uuid, version, is_current: true,
     209 |       validation_status: validated.status, validation_issues: validated.issues,
     210 |       ...migrationFields(actor),
     211 |     });
     212 |     for (const d of existing) {
     213 |       if (d.id !== record.id && d.is_current) {
     214 |         await adapters.database.update('DesignConfiguration', d.id, { is_current: false, updated_by_name: actor });
     215 |       }
     216 |     }
     217 |     await auditService.record('design_revision_saved', 'DesignConfiguration', record.uuid, `Design revision v${version} saved`, actor);
     218 |     return record;
     219 |   },
     220 |   async duplicate(project_uuid, actor) {
     221 |     const current = await designService.getCurrent(project_uuid);

--- src/services/designService.js:214 ---
     204 |     const existing = await adapters.database.filter('DesignConfiguration', { project_uuid });
     205 |     const version = (existing.length ? Math.max(...existing.map((d) => d.version || 0)) : 0) + 1;
     206 |     const validated = designService.validate(data);
     207 |     const record = await adapters.database.create('DesignConfiguration', {
     208 |       ...data, uuid: newUuid('design'), project_uuid, version, is_current: true,
     209 |       validation_status: validated.status, validation_issues: validated.issues,
     210 |       ...migrationFields(actor),
     211 |     });
     212 |     for (const d of existing) {
     213 |       if (d.id !== record.id && d.is_current) {
>>   214 |         await adapters.database.update('DesignConfiguration', d.id, { is_current: false, updated_by_name: actor });
     215 |       }
     216 |     }
     217 |     await auditService.record('design_revision_saved', 'DesignConfiguration', record.uuid, `Design revision v${version} saved`, actor);
     218 |     return record;
     219 |   },
     220 |   async duplicate(project_uuid, actor) {
     221 |     const current = await designService.getCurrent(project_uuid);
     222 |     if (!current) return null;
     223 |     const { id, uuid, created_date, updated_date, created_by_id, version, is_current, ...rest } = current;
     224 |     return designService.saveRevision(project_uuid, rest, actor);
     225 |   },
     226 |   async restore(designUuid, actor) {
     227 |     const rev = await designService.get(designUuid);
     228 |     if (!rev) return null;

--- src/services/designService.js:217 ---
     207 |     const record = await adapters.database.create('DesignConfiguration', {
     208 |       ...data, uuid: newUuid('design'), project_uuid, version, is_current: true,
     209 |       validation_status: validated.status, validation_issues: validated.issues,
     210 |       ...migrationFields(actor),
     211 |     });
     212 |     for (const d of existing) {
     213 |       if (d.id !== record.id && d.is_current) {
     214 |         await adapters.database.update('DesignConfiguration', d.id, { is_current: false, updated_by_name: actor });
     215 |       }
     216 |     }
>>   217 |     await auditService.record('design_revision_saved', 'DesignConfiguration', record.uuid, `Design revision v${version} saved`, actor);
     218 |     return record;
     219 |   },
     220 |   async duplicate(project_uuid, actor) {
     221 |     const current = await designService.getCurrent(project_uuid);
     222 |     if (!current) return null;
     223 |     const { id, uuid, created_date, updated_date, created_by_id, version, is_current, ...rest } = current;
     224 |     return designService.saveRevision(project_uuid, rest, actor);
     225 |   },
     226 |   async restore(designUuid, actor) {
     227 |     const rev = await designService.get(designUuid);
     228 |     if (!rev) return null;
     229 |     const all = await adapters.database.filter('DesignConfiguration', { project_uuid: rev.project_uuid });
     230 |     for (const d of all) {
     231 |       await adapters.database.update('DesignConfiguration', d.id, { is_current: d.uuid === designUuid, updated_by_name: actor });

--- src/services/designService.js:229 ---
     219 |   },
     220 |   async duplicate(project_uuid, actor) {
     221 |     const current = await designService.getCurrent(project_uuid);
     222 |     if (!current) return null;
     223 |     const { id, uuid, created_date, updated_date, created_by_id, version, is_current, ...rest } = current;
     224 |     return designService.saveRevision(project_uuid, rest, actor);
     225 |   },
     226 |   async restore(designUuid, actor) {
     227 |     const rev = await designService.get(designUuid);
     228 |     if (!rev) return null;
>>   229 |     const all = await adapters.database.filter('DesignConfiguration', { project_uuid: rev.project_uuid });
     230 |     for (const d of all) {
     231 |       await adapters.database.update('DesignConfiguration', d.id, { is_current: d.uuid === designUuid, updated_by_name: actor });
     232 |     }
     233 |     await auditService.record('design_restored', 'DesignConfiguration', designUuid, `Design revision v${rev.version} restored as current`, actor);
     234 |     return designService.get(designUuid);
     235 |   },
     236 |   async approveForQuote(uuid, actor) {
     237 |     const rev = await designService.get(uuid);
     238 |     if (!rev) return null;
     239 |     const v = designService.validate(rev);
     240 |     if (v.status === 'Blocked') {
     241 |       return { error: 'Cannot approve — blocking validation failures remain', validation: v };
     242 |     }
     243 |     const record = await adapters.database.update('DesignConfiguration', rev.id, { approved_for_quote: true, concept_status: 'Approved for Quote', approved_design_uuid: uuid, updated_by_name: actor });

--- src/services/designService.js:231 ---
     221 |     const current = await designService.getCurrent(project_uuid);
     222 |     if (!current) return null;
     223 |     const { id, uuid, created_date, updated_date, created_by_id, version, is_current, ...rest } = current;
     224 |     return designService.saveRevision(project_uuid, rest, actor);
     225 |   },
     226 |   async restore(designUuid, actor) {
     227 |     const rev = await designService.get(designUuid);
     228 |     if (!rev) return null;
     229 |     const all = await adapters.database.filter('DesignConfiguration', { project_uuid: rev.project_uuid });
     230 |     for (const d of all) {
>>   231 |       await adapters.database.update('DesignConfiguration', d.id, { is_current: d.uuid === designUuid, updated_by_name: actor });
     232 |     }
     233 |     await auditService.record('design_restored', 'DesignConfiguration', designUuid, `Design revision v${rev.version} restored as current`, actor);
     234 |     return designService.get(designUuid);
     235 |   },
     236 |   async approveForQuote(uuid, actor) {
     237 |     const rev = await designService.get(uuid);
     238 |     if (!rev) return null;
     239 |     const v = designService.validate(rev);
     240 |     if (v.status === 'Blocked') {
     241 |       return { error: 'Cannot approve — blocking validation failures remain', validation: v };
     242 |     }
     243 |     const record = await adapters.database.update('DesignConfiguration', rev.id, { approved_for_quote: true, concept_status: 'Approved for Quote', approved_design_uuid: uuid, updated_by_name: actor });
     244 |     await auditService.record('design_approved', 'DesignConfiguration', uuid, 'Design approved for quote (not CAD/print ready)', actor);
     245 |     return record;

--- src/services/designService.js:233 ---
     223 |     const { id, uuid, created_date, updated_date, created_by_id, version, is_current, ...rest } = current;
     224 |     return designService.saveRevision(project_uuid, rest, actor);
     225 |   },
     226 |   async restore(designUuid, actor) {
     227 |     const rev = await designService.get(designUuid);
     228 |     if (!rev) return null;
     229 |     const all = await adapters.database.filter('DesignConfiguration', { project_uuid: rev.project_uuid });
     230 |     for (const d of all) {
     231 |       await adapters.database.update('DesignConfiguration', d.id, { is_current: d.uuid === designUuid, updated_by_name: actor });
     232 |     }
>>   233 |     await auditService.record('design_restored', 'DesignConfiguration', designUuid, `Design revision v${rev.version} restored as current`, actor);
     234 |     return designService.get(designUuid);
     235 |   },
     236 |   async approveForQuote(uuid, actor) {
     237 |     const rev = await designService.get(uuid);
     238 |     if (!rev) return null;
     239 |     const v = designService.validate(rev);
     240 |     if (v.status === 'Blocked') {
     241 |       return { error: 'Cannot approve — blocking validation failures remain', validation: v };
     242 |     }
     243 |     const record = await adapters.database.update('DesignConfiguration', rev.id, { approved_for_quote: true, concept_status: 'Approved for Quote', approved_design_uuid: uuid, updated_by_name: actor });
     244 |     await auditService.record('design_approved', 'DesignConfiguration', uuid, 'Design approved for quote (not CAD/print ready)', actor);
     245 |     return record;
     246 |   },
     247 |   async copyToProject(sourceProjectUuid, targetProjectUuid, actor) {

--- src/services/designService.js:243 ---
     233 |     await auditService.record('design_restored', 'DesignConfiguration', designUuid, `Design revision v${rev.version} restored as current`, actor);
     234 |     return designService.get(designUuid);
     235 |   },
     236 |   async approveForQuote(uuid, actor) {
     237 |     const rev = await designService.get(uuid);
     238 |     if (!rev) return null;
     239 |     const v = designService.validate(rev);
     240 |     if (v.status === 'Blocked') {
     241 |       return { error: 'Cannot approve — blocking validation failures remain', validation: v };
     242 |     }
>>   243 |     const record = await adapters.database.update('DesignConfiguration', rev.id, { approved_for_quote: true, concept_status: 'Approved for Quote', approved_design_uuid: uuid, updated_by_name: actor });
     244 |     await auditService.record('design_approved', 'DesignConfiguration', uuid, 'Design approved for quote (not CAD/print ready)', actor);
     245 |     return record;
     246 |   },
     247 |   async copyToProject(sourceProjectUuid, targetProjectUuid, actor) {
     248 |     const current = await designService.getCurrent(sourceProjectUuid);
     249 |     if (!current) return null;
     250 |     const { id, uuid, created_date, updated_date, created_by_id, version, is_current, project_uuid, ...rest } = current;
     251 |     return designService.saveRevision(targetProjectUuid, rest, actor);
     252 |   },
     253 |   async setConceptStatus(uuid, status, actor) {
     254 |     const rev = await designService.get(uuid);
     255 |     if (!rev) return null;
     256 |     const record = await adapters.database.update('DesignConfiguration', rev.id, { concept_status: status, updated_by_name: actor });
     257 |     await auditService.record('concept_status', 'DesignConfiguration', uuid, `Concept status set to ${status}`, actor);

--- src/services/designService.js:244 ---
     234 |     return designService.get(designUuid);
     235 |   },
     236 |   async approveForQuote(uuid, actor) {
     237 |     const rev = await designService.get(uuid);
     238 |     if (!rev) return null;
     239 |     const v = designService.validate(rev);
     240 |     if (v.status === 'Blocked') {
     241 |       return { error: 'Cannot approve — blocking validation failures remain', validation: v };
     242 |     }
     243 |     const record = await adapters.database.update('DesignConfiguration', rev.id, { approved_for_quote: true, concept_status: 'Approved for Quote', approved_design_uuid: uuid, updated_by_name: actor });
>>   244 |     await auditService.record('design_approved', 'DesignConfiguration', uuid, 'Design approved for quote (not CAD/print ready)', actor);
     245 |     return record;
     246 |   },
     247 |   async copyToProject(sourceProjectUuid, targetProjectUuid, actor) {
     248 |     const current = await designService.getCurrent(sourceProjectUuid);
     249 |     if (!current) return null;
     250 |     const { id, uuid, created_date, updated_date, created_by_id, version, is_current, project_uuid, ...rest } = current;
     251 |     return designService.saveRevision(targetProjectUuid, rest, actor);
     252 |   },
     253 |   async setConceptStatus(uuid, status, actor) {
     254 |     const rev = await designService.get(uuid);
     255 |     if (!rev) return null;
     256 |     const record = await adapters.database.update('DesignConfiguration', rev.id, { concept_status: status, updated_by_name: actor });
     257 |     await auditService.record('concept_status', 'DesignConfiguration', uuid, `Concept status set to ${status}`, actor);
     258 |     return record;

--- src/services/designService.js:256 ---
     246 |   },
     247 |   async copyToProject(sourceProjectUuid, targetProjectUuid, actor) {
     248 |     const current = await designService.getCurrent(sourceProjectUuid);
     249 |     if (!current) return null;
     250 |     const { id, uuid, created_date, updated_date, created_by_id, version, is_current, project_uuid, ...rest } = current;
     251 |     return designService.saveRevision(targetProjectUuid, rest, actor);
     252 |   },
     253 |   async setConceptStatus(uuid, status, actor) {
     254 |     const rev = await designService.get(uuid);
     255 |     if (!rev) return null;
>>   256 |     const record = await adapters.database.update('DesignConfiguration', rev.id, { concept_status: status, updated_by_name: actor });
     257 |     await auditService.record('concept_status', 'DesignConfiguration', uuid, `Concept status set to ${status}`, actor);
     258 |     return record;
     259 |   },
     260 |   async recordFeedback(uuid, feedback, actor) {
     261 |     const rev = await designService.get(uuid);
     262 |     if (!rev) return null;
     263 |     const record = await adapters.database.update('DesignConfiguration', rev.id, { customer_feedback: feedback, updated_by_name: actor });
     264 |     await auditService.record('concept_feedback', 'DesignConfiguration', uuid, 'Customer feedback recorded', actor);
     265 |     return record;
     266 |   },
     267 |   async createConcept(project_uuid, data, actor) {
     268 |     const existing = await adapters.database.filter('DesignConfiguration', { project_uuid });
     269 |     const version = (existing.length ? Math.max(...existing.map((d) => d.version || 0)) : 0) + 1;
     270 |     const record = await adapters.database.create('DesignConfiguration', {

--- src/services/designService.js:257 ---
     247 |   async copyToProject(sourceProjectUuid, targetProjectUuid, actor) {
     248 |     const current = await designService.getCurrent(sourceProjectUuid);
     249 |     if (!current) return null;
     250 |     const { id, uuid, created_date, updated_date, created_by_id, version, is_current, project_uuid, ...rest } = current;
     251 |     return designService.saveRevision(targetProjectUuid, rest, actor);
     252 |   },
     253 |   async setConceptStatus(uuid, status, actor) {
     254 |     const rev = await designService.get(uuid);
     255 |     if (!rev) return null;
     256 |     const record = await adapters.database.update('DesignConfiguration', rev.id, { concept_status: status, updated_by_name: actor });
>>   257 |     await auditService.record('concept_status', 'DesignConfiguration', uuid, `Concept status set to ${status}`, actor);
     258 |     return record;
     259 |   },
     260 |   async recordFeedback(uuid, feedback, actor) {
     261 |     const rev = await designService.get(uuid);
     262 |     if (!rev) return null;
     263 |     const record = await adapters.database.update('DesignConfiguration', rev.id, { customer_feedback: feedback, updated_by_name: actor });
     264 |     await auditService.record('concept_feedback', 'DesignConfiguration', uuid, 'Customer feedback recorded', actor);
     265 |     return record;
     266 |   },
     267 |   async createConcept(project_uuid, data, actor) {
     268 |     const existing = await adapters.database.filter('DesignConfiguration', { project_uuid });
     269 |     const version = (existing.length ? Math.max(...existing.map((d) => d.version || 0)) : 0) + 1;
     270 |     const record = await adapters.database.create('DesignConfiguration', {
     271 |       ...data, uuid: newUuid('design'), project_uuid, version, is_current: false,

--- src/services/designService.js:263 ---
     253 |   async setConceptStatus(uuid, status, actor) {
     254 |     const rev = await designService.get(uuid);
     255 |     if (!rev) return null;
     256 |     const record = await adapters.database.update('DesignConfiguration', rev.id, { concept_status: status, updated_by_name: actor });
     257 |     await auditService.record('concept_status', 'DesignConfiguration', uuid, `Concept status set to ${status}`, actor);
     258 |     return record;
     259 |   },
     260 |   async recordFeedback(uuid, feedback, actor) {
     261 |     const rev = await designService.get(uuid);
     262 |     if (!rev) return null;
>>   263 |     const record = await adapters.database.update('DesignConfiguration', rev.id, { customer_feedback: feedback, updated_by_name: actor });
     264 |     await auditService.record('concept_feedback', 'DesignConfiguration', uuid, 'Customer feedback recorded', actor);
     265 |     return record;
     266 |   },
     267 |   async createConcept(project_uuid, data, actor) {
     268 |     const existing = await adapters.database.filter('DesignConfiguration', { project_uuid });
     269 |     const version = (existing.length ? Math.max(...existing.map((d) => d.version || 0)) : 0) + 1;
     270 |     const record = await adapters.database.create('DesignConfiguration', {
     271 |       ...data, uuid: newUuid('design'), project_uuid, version, is_current: false,
     272 |       concept_status: data.concept_status || 'Draft',
     273 |       validation_status: 'Warning', validation_issues: [],
     274 |       ...migrationFields(actor),
     275 |     });
     276 |     await auditService.record('concept_created', 'DesignConfiguration', record.uuid, `Concept "${data.concept_name || 'Untitled'}" created`, actor);
     277 |     return record;

--- src/services/designService.js:264 ---
     254 |     const rev = await designService.get(uuid);
     255 |     if (!rev) return null;
     256 |     const record = await adapters.database.update('DesignConfiguration', rev.id, { concept_status: status, updated_by_name: actor });
     257 |     await auditService.record('concept_status', 'DesignConfiguration', uuid, `Concept status set to ${status}`, actor);
     258 |     return record;
     259 |   },
     260 |   async recordFeedback(uuid, feedback, actor) {
     261 |     const rev = await designService.get(uuid);
     262 |     if (!rev) return null;
     263 |     const record = await adapters.database.update('DesignConfiguration', rev.id, { customer_feedback: feedback, updated_by_name: actor });
>>   264 |     await auditService.record('concept_feedback', 'DesignConfiguration', uuid, 'Customer feedback recorded', actor);
     265 |     return record;
     266 |   },
     267 |   async createConcept(project_uuid, data, actor) {
     268 |     const existing = await adapters.database.filter('DesignConfiguration', { project_uuid });
     269 |     const version = (existing.length ? Math.max(...existing.map((d) => d.version || 0)) : 0) + 1;
     270 |     const record = await adapters.database.create('DesignConfiguration', {
     271 |       ...data, uuid: newUuid('design'), project_uuid, version, is_current: false,
     272 |       concept_status: data.concept_status || 'Draft',
     273 |       validation_status: 'Warning', validation_issues: [],
     274 |       ...migrationFields(actor),
     275 |     });
     276 |     await auditService.record('concept_created', 'DesignConfiguration', record.uuid, `Concept "${data.concept_name || 'Untitled'}" created`, actor);
     277 |     return record;
     278 |   },

--- src/services/designService.js:268 ---
     258 |     return record;
     259 |   },
     260 |   async recordFeedback(uuid, feedback, actor) {
     261 |     const rev = await designService.get(uuid);
     262 |     if (!rev) return null;
     263 |     const record = await adapters.database.update('DesignConfiguration', rev.id, { customer_feedback: feedback, updated_by_name: actor });
     264 |     await auditService.record('concept_feedback', 'DesignConfiguration', uuid, 'Customer feedback recorded', actor);
     265 |     return record;
     266 |   },
     267 |   async createConcept(project_uuid, data, actor) {
>>   268 |     const existing = await adapters.database.filter('DesignConfiguration', { project_uuid });
     269 |     const version = (existing.length ? Math.max(...existing.map((d) => d.version || 0)) : 0) + 1;
     270 |     const record = await adapters.database.create('DesignConfiguration', {
     271 |       ...data, uuid: newUuid('design'), project_uuid, version, is_current: false,
     272 |       concept_status: data.concept_status || 'Draft',
     273 |       validation_status: 'Warning', validation_issues: [],
     274 |       ...migrationFields(actor),
     275 |     });
     276 |     await auditService.record('concept_created', 'DesignConfiguration', record.uuid, `Concept "${data.concept_name || 'Untitled'}" created`, actor);
     277 |     return record;
     278 |   },
     279 |   validate(config, project, ossiguard) {
     280 |     const issues = [];
     281 |     if (!config) return { status: 'Blocked', issues: ['No design configuration saved'] };
     282 |     // Core field checks

--- src/services/designService.js:270 ---
     260 |   async recordFeedback(uuid, feedback, actor) {
     261 |     const rev = await designService.get(uuid);
     262 |     if (!rev) return null;
     263 |     const record = await adapters.database.update('DesignConfiguration', rev.id, { customer_feedback: feedback, updated_by_name: actor });
     264 |     await auditService.record('concept_feedback', 'DesignConfiguration', uuid, 'Customer feedback recorded', actor);
     265 |     return record;
     266 |   },
     267 |   async createConcept(project_uuid, data, actor) {
     268 |     const existing = await adapters.database.filter('DesignConfiguration', { project_uuid });
     269 |     const version = (existing.length ? Math.max(...existing.map((d) => d.version || 0)) : 0) + 1;
>>   270 |     const record = await adapters.database.create('DesignConfiguration', {
     271 |       ...data, uuid: newUuid('design'), project_uuid, version, is_current: false,
     272 |       concept_status: data.concept_status || 'Draft',
     273 |       validation_status: 'Warning', validation_issues: [],
     274 |       ...migrationFields(actor),
     275 |     });
     276 |     await auditService.record('concept_created', 'DesignConfiguration', record.uuid, `Concept "${data.concept_name || 'Untitled'}" created`, actor);
     277 |     return record;
     278 |   },
     279 |   validate(config, project, ossiguard) {
     280 |     const issues = [];
     281 |     if (!config) return { status: 'Blocked', issues: ['No design configuration saved'] };
     282 |     // Core field checks
     283 |     if (!config.main_colour) issues.push({ level: 'warning', text: 'Main cover colour not set' });
     284 |     if (!config.accent_colour) issues.push({ level: 'warning', text: 'Accent colour not set' });

--- src/services/designService.js:276 ---
     266 |   },
     267 |   async createConcept(project_uuid, data, actor) {
     268 |     const existing = await adapters.database.filter('DesignConfiguration', { project_uuid });
     269 |     const version = (existing.length ? Math.max(...existing.map((d) => d.version || 0)) : 0) + 1;
     270 |     const record = await adapters.database.create('DesignConfiguration', {
     271 |       ...data, uuid: newUuid('design'), project_uuid, version, is_current: false,
     272 |       concept_status: data.concept_status || 'Draft',
     273 |       validation_status: 'Warning', validation_issues: [],
     274 |       ...migrationFields(actor),
     275 |     });
>>   276 |     await auditService.record('concept_created', 'DesignConfiguration', record.uuid, `Concept "${data.concept_name || 'Untitled'}" created`, actor);
     277 |     return record;
     278 |   },
     279 |   validate(config, project, ossiguard) {
     280 |     const issues = [];
     281 |     if (!config) return { status: 'Blocked', issues: ['No design configuration saved'] };
     282 |     // Core field checks
     283 |     if (!config.main_colour) issues.push({ level: 'warning', text: 'Main cover colour not set' });
     284 |     if (!config.accent_colour) issues.push({ level: 'warning', text: 'Accent colour not set' });
     285 |     // Logo validation
     286 |     issues.push(...validateLogo(config, project, ossiguard));
     287 |     // Text validation
     288 |     issues.push(...validateText(config, project, ossiguard));
     289 |     // Ossiguard conflict validation
     290 |     issues.push(...validateOssiguardConflicts(config, project, ossiguard));

DesignConfiguration references inspected: 37

------------------------------------------------------------
4. LOCAL BASE44 FILTER IMPLEMENTATION
------------------------------------------------------------

=== src/adapters/Base44AuthAdapter.js ===
>>     1 | import { base44 } from '@/api/base44Client';
       2 | 
       3 | /** Replaceable auth contract: currentUser, isAuthenticated and lock. */
       4 | export const Base44AuthAdapter = {
       5 |   currentUser: () => base44.auth.me(),
       6 |   isAuthenticated: () => base44.auth.isAuthenticated(),
       7 |   lock: () => base44.auth.logout('/login'),
       8 | };

=== src/adapters/Base44DatabaseAdapter.js ===
>>     1 | import { base44 } from '@/api/base44Client';
       2 | 
       3 | /** Replaceable database contract: list, filter, get, create, update and archive records by collection. */
       4 | const collection = (name) => base44.entities[name];
       5 | export const Base44DatabaseAdapter = {
       6 |   list: (name, sort = '-updated_date', limit = 500) => collection(name).list(sort, limit),
       7 |   filter: (name, query, sort = '-updated_date', limit = 500) => collection(name).filter(query, sort, limit),
       8 |   get: (name, id) => collection(name).get(id),
       9 |   create: (name, data) => collection(name).create(data),
      10 |   update: (name, id, data) => collection(name).update(id, data),
      11 |   archive: (name, id) => collection(name).update(id, { record_state: 'archived' }),
      12 |   restore: (name, id) => collection(name).update(id, { record_state: 'active' }),
      13 | };

=== src/adapters/Base44FileStorageAdapter.js ===
>>     1 | import { base44 } from '@/api/base44Client';
       2 | 
       3 | /** Replaceable storage contract: upload returns hosted location plus requested portable destination. */
       4 | export const Base44FileStorageAdapter = {
       5 |   async upload(file, destination) {
       6 |     const { file_url } = await base44.integrations.Core.UploadFile({ file });
       7 |     return { location: file_url, destination, checksum: null, verified: false, storage: 'Base44 development storage' };
       8 |   },
       9 | };

=== src/adapters/Base44FunctionAdapter.js ===
       1 | /** Replaceable server-function contract. No server functions are required in Stages 1–2. */
>>     2 | export const Base44FunctionAdapter = {
       3 |   async invoke() { throw new Error('Not yet implemented'); },
       4 | };

=== src/api/base44Client.js ===
>>     1 | import { createClient } from '@base44/sdk';
       2 | import { appParams } from '@/lib/app-params';
       3 | 
       4 | const { appId, token, functionsVersion, appBaseUrl } = appParams;
       5 | 
       6 | //Create a client with authentication required
       7 | export const base44 = createClient({
       8 |   appId,
       9 |   token,
      10 |   functionsVersion,
      11 |   serverUrl: '',
      12 |   requiresAuth: false,
      13 |   appBaseUrl
      14 | });

=== src/services/accountService.js ===
       4 | 
       5 | const ENTITY = 'WorkshopAccount';
       6 | 
       7 | export const accountService = {
       8 |   list: () => adapters.database.list(ENTITY),
>>     9 |   listByRole: (role) => adapters.database.filter(ENTITY, { role }),
      10 |   getByUserId: (userId) => adapters.database.filter(ENTITY, { user_id: userId }).then(r => r[0] || null),
      11 |   get: (uuid) => adapters.database.filter(ENTITY, { uuid }).then(r => r[0] || null),
      12 |   getByEmail: (email) => adapters.database.filter(ENTITY, { email }).then(r => r[0] || null),
      13 | 
      14 |   create: (data, actor = 'Workshop Owner') => {
      15 |     const rec = {
      16 |       uuid: newUuid('account'),
      17 |       account_status: data.account_status || 'Invited',
      18 |       permission_keys: resolvePermissions({ role: data.role, permission_preset: data.permission_preset, custom_permissions: data.custom_permissions }),
      19 |       ...migrationFields(actor),
      20 |       ...data,
      21 |     };
      42 |     if (acc) {
      43 |       if (acc.account_status === 'Suspended' || acc.account_status === 'Archived') return acc;
      44 |       return acc;
      45 |     }
      46 |     // Bootstrap: first admin-role built-in user with no owner_admin yet becomes owner_admin.
>>    47 |     const owners = await adapters.database.filter(ENTITY, { role: 'owner_admin' }, '-created_date', 10);
      48 |     const role = user.role === 'admin' && owners.length === 0 ? 'owner_admin'
      49 |       : user.role === 'admin' ? 'admin' : 'customer';
      50 |     acc = await accountService.create({
      51 |       uuid: newUuid('account'), user_id: user.id, email: user.email,
      52 |       display_name: user.full_name || user.email, role,
      53 |       permission_preset: role === 'owner_admin' ? 'owner_admin' : role === 'admin' ? 'workshop_admin' : 'customer',
      54 |       account_status: 'Active', email_verified: true,
      55 |       last_login: new Date().toISOString(),
      56 |     }, actorName);

=== src/services/completedCoverService.js ===
       2 | import { auditService } from '@/services/auditService';
       3 | import { orderService } from '@/services/orderService';
       4 | import { designService } from '@/services/designService';
       5 | export const completedCoverService = {
       6 |   list: () => adapters.database.list('CompletedCover'),
>>     7 |   forCustomer: (customer_uuid) => adapters.database.filter('CompletedCover', { customer_uuid }),
       8 |   forProject: (project_uuid) => adapters.database.filter('CompletedCover', { project_uuid }),
       9 |   get: async (uuid) => (await adapters.database.filter('CompletedCover', { uuid }, '-updated_date', 1))[0],
      10 |   async create(data, actor) { const record = await adapters.database.create('CompletedCover', { ...data, uuid: newUuid('cover'), cover_reference: `SHC-${Date.now().toString().slice(-6)}`, data_origin: data.data_origin || 'Workshop Created', reorder_status: 'Not reordered', ...migrationFields(actor) }); await auditService.record('cover_completed', 'CompletedCover', record.uuid, `Completed cover ${record.cover_reference}`, actor); return record; },
      11 |   async update(id, uuid, data, actor) { const { id: _id, created_date, updated_date, created_by_id, ...editable } = data; const record = await adapters.database.update('CompletedCover', id, { ...editable, updated_by_name: actor }); return record; },
      12 |   async reorder(cover, actor) { const order = await orderService.create({ project_uuid: cover.project_uuid, customer_uuid: cover.customer_uuid, cover_revision: (cover.revision || 1), funding_type: 'Private payer', quote_amount: 0, balance: 0, production_status: 'Ready for CAD' }, actor); await completedCoverService.update(cover.id, cover.uuid, { reorder_status: 'Reordered' }, actor); await auditService.record('cover_reorder', 'CompletedCover', cover.uuid, `Reorder placed as ${order.order_number}`, actor); return { order, cover }; },
      13 |   async newDesignFromFit(cover, project, actor) { const { id, created_date, updated_date, created_by_id, ...rest } = project; const revisionProject = await adapters.database.create('CoverProject', { ...rest, uuid: newUuid('proj'), project_id: `${project.project_id}-R${(project.revision || 1) + 1}`, revision: (project.revision || 1) + 1, status: 'Ready for design', reason_for_cover: `New design using fit from ${cover.cover_reference}`, data_origin: 'Workshop Created', ...migrationFields(actor) }); await auditService.record('project_revision_created', 'CoverProject', revisionProject.uuid, `New revision ${revisionProject.project_id} from ${cover.cover_reference}`, actor); try { await designService.copyToProject(project.uuid, revisionProject.uuid, actor); } catch (_) { /* design copy is best-effort */ } return revisionProject; },
      14 |   async replace(cover, actor) { const order = await orderService.create({ project_uuid: cover.project_uuid, customer_uuid: cover.customer_uuid, cover_revision: (cover.revision || 1), funding_type: 'Private payer', quote_amount: 0, balance: 0, production_status: 'Ready for CAD' }, actor); await completedCoverService.update(cover.id, cover.uuid, { reorder_status: 'Replacement in progress' }, actor); await auditService.record('cover_replacement', 'CompletedCover', cover.uuid, `Replacement order ${order.order_number}`, actor); return order; },
      15 |   async reportFitIssue(cover, note, actor) { await completedCoverService.update(cover.id, cover.uuid, { fit_review_result: 'Refit required', notes: (cover.notes ? cover.notes + '\n' : '') + 'Fit issue: ' + note }, actor); return auditService.record('fit_issue_reported', 'CompletedCover', cover.uuid, `Fit issue reported: ${note}`, actor); },
      16 |   archive: async (record, actor) => { await adapters.database.archive('CompletedCover', record.id); return auditService.record('cover_archived', 'CompletedCover', record.uuid, 'Cover archived', actor); },
      17 |   restore: async (record, actor) => { await adapters.database.restore('CompletedCover', record.id); return auditService.record('cover_restored', 'CompletedCover', record.uuid, 'Cover restored', actor); },
      18 | };

=== src/services/componentService.js ===
       1 | import { adapters, migrationFields, newUuid } from '@/services/serviceConfig';
       2 | import { auditService } from '@/services/auditService';
       3 | export const componentService = {
       4 |   list: () => adapters.database.list('Component'),
>>     5 |   get: async (uuid) => (await adapters.database.filter('Component', { uuid }, '-updated_date', 1))[0],
       6 |   async create(data, actor) { const { id, created_date, updated_date, created_by_id, ...portable } = data; const record = await adapters.database.create('Component', { ...portable, uuid: newUuid('comp'), confidence: data.confidence || 'Unverified', data_source: data.data_source || 'Unknown', status: 'active', ...migrationFields(actor) }); await auditService.record('component_created', 'Component', record.uuid, `Created ${record.manufacturer} ${record.model}`, actor); return record; },
       7 |   async update(record, data, actor) { const { id, created_date, updated_date, created_by_id, ...editable } = data; const updated = await adapters.database.update('Component', record.id, { ...editable, updated_by_name: actor }); await auditService.record('component_changed', 'Component', record.uuid, `Updated ${record.manufacturer} ${record.model}`, actor); return updated; },
       8 |   archive: async (record, actor = 'Ray') => { await adapters.database.archive('Component', record.id); return auditService.record('component_archived', 'Component', record.uuid, `Archived ${record.manufacturer} ${record.model}`, actor); },
       9 |   restore: async (record, actor = 'Ray') => { await adapters.database.restore('Component', record.id); return auditService.record('component_restored', 'Component', record.uuid, `Restored ${record.manufacturer} ${record.model}`, actor); },
      10 |   copy: (record, actor) => componentService.create({ ...record, id: undefined, uuid: undefined, data_label: 'CUSTOMER-SPECIFIC COPY', model: `${record.model} — customer measured`, data_source: 'Workshop measured', confidence: 'Low' }, actor),
      11 | };

=== src/services/customerService.js ===
       1 | import { adapters, migrationFields, newUuid } from '@/services/serviceConfig';
       2 | import { auditService } from '@/services/auditService';
       3 | export const customerService = {
       4 |   list: () => adapters.database.list('Customer'),
>>     5 |   get: async (uuid) => (await adapters.database.filter('Customer', { uuid }, '-updated_date', 1))[0],
       6 |   history: async (uuid) => ({ limbs: await adapters.database.filter('LimbProfile', { customer_uuid: uuid }), prostheses: await adapters.database.filter('Prosthesis', { customer_uuid: uuid }), projects: await adapters.database.filter('CoverProject', { customer_uuid: uuid }) }),
       7 |   async create(data, actor) { const record = await adapters.database.create('Customer', { ...data, uuid: newUuid('cust'), customer_number: `SLC-${Date.now().toString().slice(-6)}`, data_label: data.data_label || 'WORKSHOP RECORD', ...migrationFields(actor) }); await auditService.record('customer_created', 'Customer', record.uuid, `Created customer ${record.customer_number}`, actor); return record; },
       8 |   async update(id, uuid, data, actor) { const { id: _id, created_date, updated_date, created_by_id, ...editable } = data; const record = await adapters.database.update('Customer', id, { ...editable, updated_by_name: actor }); await auditService.record('customer_edited', 'Customer', uuid, 'Customer details updated', actor); return record; },
       9 |   archive: async (record, actor) => { await adapters.database.archive('Customer', record.id); return auditService.record('customer_archived', 'Customer', record.uuid, 'Customer archived', actor); },
      10 |   restore: async (record, actor) => { await adapters.database.restore('Customer', record.id); return auditService.record('customer_restored', 'Customer', record.uuid, 'Customer restored', actor); },
      11 |   async createLimb(data, actor) { const record = await adapters.database.create('LimbProfile', { ...data, uuid: newUuid('limb'), ...migrationFields(actor) }); await auditService.record('limb_profile_created', 'LimbProfile', record.uuid, `Created ${record.profile_name}`, actor); return record; },
      12 |   async createProsthesis(data, actor) { const record = await adapters.database.create('Prosthesis', { ...data, uuid: newUuid('pros'), status: 'active', ...migrationFields(actor) }); await auditService.record('prosthesis_created', 'Prosthesis', record.uuid, `Created ${record.name}`, actor); return record; },
      13 | };

=== src/services/dashboardService.js ===
       1 | import { adapters } from '@/services/serviceConfig';
>>     2 | export const dashboardService = { async summary() { const [projects, sessions, customers] = await Promise.all([adapters.database.list('CoverProject'), adapters.database.list('MeasurementSession'), adapters.database.list('Customer')]); const count = (status) => projects.filter(p => p.record_state === 'active' && p.status === status).length; const projectCustomers = projects.reduce((a,p) => ({ ...a, [p.customer_uuid]: (a[p.customer_uuid] || 0) + 1 }), {}); return { projects, customers, active: projects.filter(p => p.record_state === 'active' && p.status !== 'Complete').length, measurements: sessions.filter(s => s.status !== 'Complete').length, clarification: count('Awaiting customer clarification'), selection: count('Designs awaiting selection'), review: count('Awaiting workshop review'), completed: projects.filter(p => p.status === 'Complete').slice(0,5), returning: Object.values(projectCustomers).filter(v => v > 1).length }; } };

=== src/services/designService.js ===
     164 |   return issues;
     165 | }
     166 | 
     167 | export const designService = {
     168 |   list: () => adapters.database.list('DesignConfiguration'),
>>   169 |   forProject: (project_uuid) => adapters.database.filter('DesignConfiguration', { project_uuid }, '-version'),
     170 |   getConcepts: (project_uuid) => {
     171 |     const all = adapters.database.filter('DesignConfiguration', { project_uuid }, '-version');
     172 |     return all;
     173 |   },
     174 |   getCurrent: async (project_uuid) => {
     175 |     const all = await adapters.database.filter('DesignConfiguration', { project_uuid, is_current: true }, '-version', 1);
     176 |     return all[0] || null;
     177 |   },
     178 |   get: async (uuid) => (await adapters.database.filter('DesignConfiguration', { uuid }, '-updated_date', 1))[0],
     179 |   async create(data, actor) {
     180 |     const existing = await adapters.database.filter('DesignConfiguration', { project_uuid: data.project_uuid });
     181 |     const version = (existing.length ? Math.max(...existing.map((d) => d.version || 0)) : 0) + 1;
     182 |     const record = await adapters.database.create('DesignConfiguration', {
     183 |       ...data, uuid: newUuid('design'), version, is_current: true,
     184 |       validation_status: data.validation_status || 'Warning',
     185 |       validation_issues: data.validation_issues || [],
     186 |       ...migrationFields(actor),
     187 |     });
     188 |     for (const d of existing) {
     189 |       if (d.id !== record.id && d.is_current) {
     199 |     const record = await adapters.database.update('DesignConfiguration', id, { ...editable, validation_status: validated.status, validation_issues: validated.issues, updated_by_name: actor });
     200 |     await auditService.record('design_updated', 'DesignConfiguration', uuid, 'Design configuration updated', actor);
     201 |     return record;
     202 |   },
     203 |   async saveRevision(project_uuid, data, actor) {
>>   204 |     const existing = await adapters.database.filter('DesignConfiguration', { project_uuid });
     205 |     const version = (existing.length ? Math.max(...existing.map((d) => d.version || 0)) : 0) + 1;
     206 |     const validated = designService.validate(data);
     207 |     const record = await adapters.database.create('DesignConfiguration', {
     208 |       ...data, uuid: newUuid('design'), project_uuid, version, is_current: true,
     209 |       validation_status: validated.status, validation_issues: validated.issues,
     210 |       ...migrationFields(actor),
     211 |     });
     212 |     for (const d of existing) {
     213 |       if (d.id !== record.id && d.is_current) {
     224 |     return designService.saveRevision(project_uuid, rest, actor);
     225 |   },
     226 |   async restore(designUuid, actor) {
     227 |     const rev = await designService.get(designUuid);
     228 |     if (!rev) return null;
>>   229 |     const all = await adapters.database.filter('DesignConfiguration', { project_uuid: rev.project_uuid });
     230 |     for (const d of all) {
     231 |       await adapters.database.update('DesignConfiguration', d.id, { is_current: d.uuid === designUuid, updated_by_name: actor });
     232 |     }
     233 |     await auditService.record('design_restored', 'DesignConfiguration', designUuid, `Design revision v${rev.version} restored as current`, actor);
     234 |     return designService.get(designUuid);
     235 |   },
     236 |   async approveForQuote(uuid, actor) {
     237 |     const rev = await designService.get(uuid);
     238 |     if (!rev) return null;
     263 |     const record = await adapters.database.update('DesignConfiguration', rev.id, { customer_feedback: feedback, updated_by_name: actor });
     264 |     await auditService.record('concept_feedback', 'DesignConfiguration', uuid, 'Customer feedback recorded', actor);
     265 |     return record;
     266 |   },
     267 |   async createConcept(project_uuid, data, actor) {
>>   268 |     const existing = await adapters.database.filter('DesignConfiguration', { project_uuid });
     269 |     const version = (existing.length ? Math.max(...existing.map((d) => d.version || 0)) : 0) + 1;
     270 |     const record = await adapters.database.create('DesignConfiguration', {
     271 |       ...data, uuid: newUuid('design'), project_uuid, version, is_current: false,
     272 |       concept_status: data.concept_status || 'Draft',
     273 |       validation_status: 'Warning', validation_issues: [],
     274 |       ...migrationFields(actor),
     275 |     });
     276 |     await auditService.record('concept_created', 'DesignConfiguration', record.uuid, `Concept "${data.concept_name || 'Untitled'}" created`, actor);
     277 |     return record;

=== src/services/dimensionService.js ===
       3 | import { MANUFACTURER_SPEC_FIELDS } from '@/services/dimensionDefinitions';
       4 | 
       5 | const today = () => new Date().toISOString().slice(0, 10);
       6 | 
       7 | export const dimensionService = {
>>     8 |   dimensions: (componentUuid) => adapters.database.filter('ComponentDimension', { component_uuid: componentUuid }),
       9 |   specs: (componentUuid) => adapters.database.filter('ComponentSpec', { component_uuid: componentUuid }),
      10 |   stations: (componentUuid) => adapters.database.filter('EnvelopeStation', { component_uuid: componentUuid }),
      11 |   accessPoints: (componentUuid) => adapters.database.filter('AccessPoint', { component_uuid: componentUuid }),
      12 |   keepOutZones: (componentUuid) => adapters.database.filter('KeepOutZone', { component_uuid: componentUuid }),
      13 |   movementPositions: (componentUuid) => adapters.database.filter('MovementPosition', { component_uuid: componentUuid }),
      14 |   assemblyComponents: (projectUuid) => adapters.database.filter('AssemblyComponent', { project_uuid: projectUuid }),
      15 |   componentAssembly: (componentUuid) => adapters.database.filter('AssemblyComponent', { component_uuid: componentUuid }),
      16 | 
      17 |   async saveDimension(data, actor) {
      18 |     const { id, created_date, updated_date, created_by_id, ...portable } = data;
      19 |     const value_mm = portable.entered_unit === 'cm' && portable.original_value != null ? Number(portable.original_value) * 10 : portable.value_mm;
      20 |     const existing = (await adapters.database.filter('ComponentDimension', { component_uuid: portable.component_uuid, dimension_key: portable.dimension_key, record_state: 'active' }, '-updated_date', 50))
      21 |       .filter(d => d.session_uuid === (portable.session_uuid || null) || !d.session_uuid);
      22 |     const payload = { ...portable, value_mm, date_entered: portable.date_entered || today(), updated_by_name: actor };
      23 |     let saved;
      24 |     if (existing[0]?.id) { saved = await adapters.database.update('ComponentDimension', existing[0].id, payload); }
      25 |     else { saved = await adapters.database.create('ComponentDimension', { ...payload, uuid: newUuid('dim'), ...migrationFields(actor) }); }
      26 |     await auditService.record('dimension_saved', 'ComponentDimension', saved.uuid, `Saved ${portable.dimension_name}`, actor, payload.warning || '');
      27 |     return saved;
      28 |   },
      29 | 
      30 |   async importSpec(component, specData, actor) {
      53 |     return spec;
      54 |   },
      55 | 
      56 |   async saveStation(data, actor) {
      57 |     const { id, created_date, updated_date, created_by_id, ...portable } = data;
>>    58 |     const existing = (await adapters.database.filter('EnvelopeStation', { component_uuid: portable.component_uuid, station_name: portable.station_name, session_uuid: portable.session_uuid || '' }, '-updated_date', 1))[0];
      59 |     const payload = { ...portable, date_entered: portable.date_entered || today(), entered_by: actor };
      60 |     const saved = existing ? await adapters.database.update('EnvelopeStation', existing.id, payload) : await adapters.database.create('EnvelopeStation', { ...payload, uuid: newUuid('station'), ...migrationFields(actor) });
      61 |     await auditService.record('station_saved', 'EnvelopeStation', saved.uuid, `Saved station ${portable.station_name}`, actor);
      62 |     return saved;
      63 |   },
      64 | 
      65 |   async saveAccessPoint(data, actor) {
      66 |     const { id, created_date, updated_date, created_by_id, ...portable } = data;
      67 |     const saved = await adapters.database.create('AccessPoint', { ...portable, uuid: newUuid('access'), date_entered: today(), entered_by: actor, ...migrationFields(actor) });
      76 |     return saved;
      77 |   },
      78 | 
      79 |   async saveMovementPosition(data, actor) {
      80 |     const { id, created_date, updated_date, created_by_id, ...portable } = data;
>>    81 |     const existing = (await adapters.database.filter('MovementPosition', { component_uuid: portable.component_uuid, position_name: portable.position_name, session_uuid: portable.session_uuid || '' }, '-updated_date', 1))[0];
      82 |     const payload = { ...portable, date_entered: portable.date_entered || today(), entered_by: actor };
      83 |     const saved = existing ? await adapters.database.update('MovementPosition', existing.id, payload) : await adapters.database.create('MovementPosition', { ...payload, uuid: newUuid('move'), ...migrationFields(actor) });
      84 |     await auditService.record('movement_saved', 'MovementPosition', saved.uuid, `Saved movement ${portable.position_name}`, actor);
      85 |     return saved;
      86 |   },
      87 | 
      88 |   async saveAssemblyComponent(data, actor) {
      89 |     const { id, created_date, updated_date, created_by_id, ...portable } = data;
      90 |     const saved = await adapters.database.create('AssemblyComponent', { ...portable, uuid: newUuid('assembly'), date_entered: today(), entered_by: actor, ...migrationFields(actor) });

=== src/services/fileStorageService.js ===
       1 | import { adapters } from '@/services/serviceConfig';
       2 | export const fileStorageService = {
       3 |   uploadMeasurementPhoto: (file, projectUuid) => adapters.files.upload(file, `/SHiREVault/SHiRELimbs/Measurements/${projectUuid}`),
>>     4 |   storageNotice: 'Files are in Base44 development storage. The SHiREVault path is a portability destination only.',
       5 | };

=== src/services/invitationService.js ===
       9 | };
      10 | const DAYS = 7;
      11 | 
      12 | export const invitationService = {
      13 |   list: () => adapters.database.list(ENTITY),
>>    14 |   get: (uuid) => adapters.database.filter(ENTITY, { uuid }).then(r => r[0] || null),
      15 |   getByToken: (token) => adapters.database.filter(ENTITY, { token }).then(r => r[0] || null),
      16 |   getPendingByEmail: (email) => adapters.database.filter(ENTITY, { email, status: 'pending' }).then(r => r[0] || null),
      17 | 
      18 |   create: ({ email, intended_role, permission_preset, custom_permissions, linked_customer_uuid, linked_customer_number, linked_builder_profile_uuid, notes, expiryDays = DAYS }, actor = 'Workshop Owner') => {
      19 |     const now = new Date();
      20 |     const expiry = new Date(now.getTime() + expiryDays * 86400000);
      21 |     const rec = {
      22 |       uuid: newUuid('invite'),
      23 |       token: genToken(),
      24 |       email, intended_role, permission_preset, custom_permissions,
      25 |       linked_customer_uuid, linked_customer_number, linked_builder_profile_uuid,

=== src/services/limbProfileService.js ===
       1 | import { adapters } from '@/services/serviceConfig';
>>     2 | export const limbProfileService = { list: () => adapters.database.list('LimbProfile'), byCustomer: (customer_uuid) => adapters.database.filter('LimbProfile', { customer_uuid }) };

=== src/services/manufacturingService.js ===
       1 | import { adapters, migrationFields, newUuid } from '@/services/serviceConfig';
       2 | import { auditService } from '@/services/auditService';
       3 | export const manufacturingService = {
       4 |   list: () => adapters.database.list('ManufacturingJob'),
>>     5 |   forOrder: (order_uuid) => adapters.database.filter('ManufacturingJob', { order_uuid }),
       6 |   forProject: (project_uuid) => adapters.database.filter('ManufacturingJob', { project_uuid }),
       7 |   forCustomer: (customer_uuid) => adapters.database.filter('ManufacturingJob', { customer_uuid }),
       8 |   get: async (uuid) => (await adapters.database.filter('ManufacturingJob', { uuid }, '-updated_date', 1))[0],
       9 |   async create(data, actor) { const record = await adapters.database.create('ManufacturingJob', { ...data, uuid: newUuid('mfg'), job_reference: `MFG-${Date.now().toString().slice(-6)}`, status: data.status || 'Waiting', data_origin: data.data_origin || 'Workshop Created', ...migrationFields(actor) }); await auditService.record('manufacturing_created', 'ManufacturingJob', record.uuid, `Created job ${record.job_reference}`, actor); return record; },
      10 |   async setStatus(id, uuid, status, actor) { const patch = { status, updated_by_name: actor }; if (status === 'Complete') patch.completed_date = new Date().toISOString().slice(0, 10); if (status === 'Printing' && !actor._noStart) patch.started_date = new Date().toISOString().slice(0, 10); await adapters.database.update('ManufacturingJob', id, patch); return auditService.record('manufacturing_status', 'ManufacturingJob', uuid, `Status → ${status}`, actor); },
      11 |   async linkCover(id, uuid, coverUuid, actor) { await adapters.database.update('ManufacturingJob', id, { completed_cover_uuid: coverUuid, updated_by_name: actor }); return auditService.record('manufacturing_cover_linked', 'ManufacturingJob', uuid, 'Linked to completed cover', actor); },
      12 |   archive: async (record, actor) => { await adapters.database.archive('ManufacturingJob', record.id); return auditService.record('manufacturing_archived', 'ManufacturingJob', record.uuid, 'Job archived', actor); },
      13 |   restore: async (record, actor) => { await adapters.database.restore('ManufacturingJob', record.id); return auditService.record('manufacturing_restored', 'ManufacturingJob', record.uuid, 'Job restored', actor); },
      14 | };

=== src/services/measurementGeometryService.js ===
>>     1 | import { base44 } from '@/api/base44Client';
       2 | import { convertStationsToRings } from '@/components/viewportV2/AnatomicalMesh';
       3 | 
       4 | export const MM_PER_UNIT = 70;
       5 | export const SOCKET_BASE_Y = 2.92;
       6 | export const COVER_BASE_Y = 2.78;
       7 | 
       8 | export const GEOMETRY_STATUS = {
       9 |   generic: 'Generic visual geometry — not customer-specific and not manufacturing CAD.',
      10 |   measurement: 'Measurement-driven visualisation — review required and not manufacturing geometry.',
      25 |  * it receives this prepared object via props.
      26 |  */
      27 | export async function loadProjectGeometry(projectUuid) {
      28 |   if (!projectUuid) return emptyGeometry();
      29 |   let project = null;
>>    30 |   try { project = await base44.entities.CoverProject.get(projectUuid); } catch (_) { project = null; }
      31 | 
      32 |   let sessions = [];
      33 |   try { sessions = await base44.entities.MeasurementSession.filter({ project_uuid: projectUuid }); } catch (_) {}
      34 |   sessions = (sessions || []).filter((s) => s.record_state !== 'archived');
      35 |   const sessionIds = sessions.map((s) => s.uuid);
      36 | 
      37 |   let stations = [];
      38 |   if (sessionIds.length) {
      39 |     try { stations = await base44.entities.EnvelopeStation.filter({ session_uuid: { $in: sessionIds } }); } catch (_) { stations = []; }
      40 |     if (!stations.length) {
      41 |       for (const sid of sessionIds) {
      42 |         try { const part = await base44.entities.EnvelopeStation.filter({ session_uuid: sid }); if (part) stations = stations.concat(part); } catch (_) {}
      43 |       }
      44 |     }
      45 |   }
      46 |   stations = stations || [];
      47 | 
      48 |   const withDims = stations.filter((s) => (s.total_width_mm || (s.max_medial_mm != null && s.max_lateral_mm != null)) && (s.total_depth_mm || (s.max_anterior_mm != null && s.max_posterior_mm != null)));
      49 | 
      50 |   const coverRings = convertStationsToRings(stations, MM_PER_UNIT, COVER_BASE_Y, 1);
      51 |   const socketRings = convertStationsToRings(stations, MM_PER_UNIT, SOCKET_BASE_Y, 0.82);
      52 | 
      53 |   let status = 'generic';
      54 |   if (withDims.length >= 6) status = 'ready';
      55 |   else if (withDims.length > 0) status = 'measurement';
      56 | 
      57 |   return {
      89 |  * Upsert a workshop cross-section station measurement (drives geometry).
      90 |  */
      91 | export async function saveStationMeasurement({ sessionUuid, componentUuid, station }) {
      92 |   let existing = null;
      93 |   try {
>>    94 |     const list = await base44.entities.EnvelopeStation.filter({ session_uuid: sessionUuid, station_name: station.station_name });
      95 |     if (list && list.length) existing = list[0];
      96 |   } catch (_) {}
      97 |   const today = new Date().toISOString().slice(0, 10);
      98 |   const payload = {
      99 |     component_uuid: componentUuid || 'generic',
     100 |     session_uuid: sessionUuid,
     101 |     station_name: station.station_name,
     102 |     height_from_origin_mm: num(station.height_from_origin_mm),
     103 |     total_width_mm: num(station.total_width_mm),
     111 |     shape_classification: station.shape_classification || 'Workshop measured',
     112 |     entered_by: station.entered_by || 'Workshop',
     113 |     date_entered: today,
     114 |     notes: station.notes || '',
     115 |   };
>>   116 |   if (existing) return base44.entities.EnvelopeStation.update(existing.id, payload);
     117 |   return base44.entities.EnvelopeStation.create(payload);
     118 | }
     119 | 
     120 | const num = (v) => (v === '' || v == null ? undefined : Number(v));

=== src/services/measurementService.js ===
       1 | import { adapters, migrationFields, newUuid } from '@/services/serviceConfig';
       2 | import { auditService } from '@/services/auditService';
       3 | export const measurementService = {
       4 |   sessions: () => adapters.database.list('MeasurementSession'),
>>     5 |   session: async (uuid) => (await adapters.database.filter('MeasurementSession', { uuid }, '-updated_date', 1))[0],
       6 |   definitions: (workflow) => adapters.database.filter('MeasurementDefinition', { workflow, active: true }, 'sequence'),
       7 |   values: (session_uuid) => adapters.database.filter('MeasurementValue', { session_uuid }),
       8 |   async save(session, definition, data, actor) { const existing = (await adapters.database.filter('MeasurementValue', { session_uuid: session.uuid, definition_uuid: definition.uuid }, '-updated_date', 1))[0]; const previous = (await adapters.database.filter('MeasurementValue', { definition_uuid: definition.uuid }, '-measured_date', 20)).find(v => v.session_uuid !== session.uuid && v.value_mm); const value_mm = data.entered_unit === 'cm' ? Number(data.value) * 10 : Number(data.value); const warnings = []; if (definition.unit === 'mm' && (value_mm < definition.minimum_value || value_mm > definition.maximum_value)) warnings.push(`Outside expected range ${definition.minimum_value}–${definition.maximum_value} mm.`); if (data.entered_unit === 'mm' && value_mm < definition.minimum_value && value_mm * 10 <= definition.maximum_value) warnings.push('Likely wrong unit: this value may have been entered in centimetres.'); if (previous && Math.abs(value_mm - previous.value_mm) / previous.value_mm > 0.2) warnings.push(`More than 20% different from a previous ${definition.name} record.`); const warning = warnings.length ? `${warnings.join(' ')} Manual review required.` : ''; const payload = { value_mm, entered_unit: data.entered_unit, confidence: data.confidence, measured_by: actor, measured_date: new Date().toISOString().slice(0,10), notes: data.notes, photo_url: data.photo_url || '', storage_destination: data.storage_destination || '', warning, updated_by_name: actor }; const saved = existing ? await adapters.database.update('MeasurementValue', existing.id, payload) : await adapters.database.create('MeasurementValue', { ...payload, uuid: newUuid('measure'), session_uuid: session.uuid, definition_uuid: definition.uuid, project_uuid: session.project_uuid, ...migrationFields(actor) }); await auditService.record('measurement_changed', 'MeasurementValue', saved.uuid, `Saved ${definition.name}`, actor, warning); return saved; },
       9 |   async skip(session, definition, reason, actor) { const saved = await adapters.database.create('MeasurementValue', { uuid: newUuid('measure'), session_uuid: session.uuid, definition_uuid: definition.uuid, project_uuid: session.project_uuid, entered_unit: 'text', skip_reason: reason, measured_by: actor, measured_date: new Date().toISOString().slice(0,10), ...migrationFields(actor) }); await auditService.record('measurement_skipped', 'MeasurementValue', saved.uuid, `Skipped ${definition.name}: ${reason}`, actor); return saved; },
      10 |   progress: (session, complete, total) => adapters.database.update('MeasurementSession', session.id, { progress_percent: Math.round((complete / total) * 100), status: complete >= total ? 'Complete' : 'In progress' }),
      11 |   pause: (session) => adapters.database.update('MeasurementSession', session.id, { status: 'Paused' }),
      12 | };

=== src/services/notificationService.js ===
       5 | // callers must not claim an email was sent. This service records in-app notifications only.
       6 | const ENTITY = 'Notification';
       7 | 
       8 | export const notificationService = {
       9 |   list: () => adapters.database.list(ENTITY),
>>    10 |   listForUser: (userId) => adapters.database.filter(ENTITY, { target_user_id: userId }),
      11 |   create: ({ target_user_id, target_email, type, title, body, link, related_uuid }, actor = 'Workshop Owner') =>
      12 |     adapters.database.create(ENTITY, {
      13 |       uuid: newUuid('notif'), target_user_id, target_email, type, title, body, link, related_uuid,
      14 |       read: false, created_date: new Date().toISOString(),
      15 |       ...migrationFields(actor),
      16 |     }),
      17 | 
      18 |   // Helpers for common events. Returns { emailDelivered: false } so the UI can show the honest message.
      19 |   notify: async (opts) => {

=== src/services/orderService.js ===
       1 | import { adapters, migrationFields, newUuid } from '@/services/serviceConfig';
       2 | import { auditService } from '@/services/auditService';
       3 | import { quoteService } from '@/services/quoteService';
       4 | export const orderService = {
       5 |   list: () => adapters.database.list('Order'),
>>     6 |   forProject: (project_uuid) => adapters.database.filter('Order', { project_uuid }),
       7 |   forCustomer: (customer_uuid) => adapters.database.filter('Order', { customer_uuid }),
       8 |   get: async (uuid) => (await adapters.database.filter('Order', { uuid }, '-updated_date', 1))[0],
       9 |   async create(data, actor) { const record = await adapters.database.create('Order', { ...data, uuid: newUuid('order'), order_number: `ORD-${Date.now().toString().slice(-6)}`, order_date: data.order_date || new Date().toISOString().slice(0, 10), production_status: data.production_status || 'Awaiting measurements', shipping_status: data.shipping_status || 'Not started', payment_status: data.payment_status || 'Unpaid', funding_approval_status: data.funding_approval_status || 'Not requested', invoice_status: data.invoice_status || 'Not issued', deposit: data.deposit || 0, balance: data.balance || (data.quote_amount || 0), data_origin: data.data_origin || 'Workshop Created', ...migrationFields(actor) }); await auditService.record('order_created', 'Order', record.uuid, `Created order ${record.order_number}`, actor); return record; },
      10 |   async createFromQuote(quote, project, actor) { return orderService.create({ project_uuid: project.uuid, customer_uuid: project.customer_uuid, quote_uuid: quote.uuid, cover_revision: project.revision, funding_type: quote.funding_type, quote_amount: quote.amount, balance: quote.amount }, actor); },
      11 |   async update(id, uuid, data, actor) { const { id: _id, created_date, updated_date, created_by_id, ...editable } = data; const record = await adapters.database.update('Order', id, { ...editable, updated_by_name: actor }); await auditService.record('order_updated', 'Order', uuid, 'Order updated', actor); return record; },
      12 |   async setStatus(id, uuid, status, actor) { await adapters.database.update('Order', id, { production_status: status, updated_by_name: actor }); return auditService.record('order_status_changed', 'Order', uuid, `Production status → ${status}`, actor); },
      13 |   async recordPayment(id, uuid, amount, actor) { const order = (await adapters.database.filter('Order', { uuid }, '-updated_date', 1))[0]; const deposit = (order.deposit || 0) + Number(amount); const total = order.quote_amount || 0; const balance = Math.max(0, total - deposit); const payment_status = balance <= 0 ? 'Paid' : deposit > 0 ? 'Deposit paid' : 'Unpaid'; await adapters.database.update('Order', id, { deposit, balance, payment_status, updated_by_name: actor }); return auditService.record('payment_recorded', 'Order', uuid, `Payment of ${amount} recorded`, actor); },
      14 |   async cancel(id, uuid, reason, actor) { await adapters.database.update('Order', id, { production_status: 'Awaiting measurements', cancel_reason: reason, record_state: 'archived', updated_by_name: actor }); return auditService.record('order_cancelled', 'Order', uuid, `Order cancelled: ${reason}`, actor); },
      15 |   archive: async (record, actor) => { await adapters.database.archive('Order', record.id); return auditService.record('order_archived', 'Order', record.uuid, 'Order archived', actor); },
      16 |   restore: async (record, actor) => { await adapters.database.restore('Order', record.id); return auditService.record('order_restored', 'Order', record.uuid, 'Order restored', actor); },
      17 |   prepareQuote: (project, actor) => quoteService.create({ project_uuid: project.uuid, customer_uuid: project.customer_uuid, amount: 0, funding_type: 'Quote-only' }, actor),
      18 | };

=== src/services/ossiguardService.js ===
      11 | 
      12 | export const PROHIBITED_ATTACH_TARGETS = ['Osseointegration implant', 'Abutment', 'Stoma', 'Skin', 'Residual limb', 'Unknown structural component', 'Joint movement surface', 'Safety-release mechanism'];
      13 | 
      14 | export const ossiguardService = {
      15 |   list: () => adapters.database.list('OssiguardProfile'),
>>    16 |   forCustomer: (customer_uuid) => adapters.database.filter('OssiguardProfile', { customer_uuid }, '-connector_revision'),
      17 |   get: async (uuid) => (await adapters.database.filter('OssiguardProfile', { uuid }, '-updated_date', 1))[0],
      18 | 
      19 |   async create(data, actor) {
      20 |     const { id, created_date, updated_date, created_by_id, ...portable } = data;
      21 |     const record = await adapters.database.create('OssiguardProfile', {
      22 |       ...portable,
      23 |       uuid: newUuid('ossiguard'),
      24 |       geometry_status: data.geometry_status || 'Visual Reference',
      25 |       approval_status: data.approval_status || 'Prototype',
      26 |       connector_revision: data.connector_revision || 1,
      97 |     return record;
      98 |   },
      99 | 
     100 |   async listRevisions(profileName) {
     101 |     const all = await adapters.database.list('OssiguardProfile');
>>   102 |     return all.filter((p) => p.profile_name === profileName).sort((a, b) => (b.connector_revision || 0) - (a.connector_revision || 0));
     103 |   },
     104 | 
     105 |   validate(profile, project) {
     106 |     if (!profile) return { status: 'Blocked', issues: ['No Ossiguard profile selected'], level: 'blocked', issueObjects: [] };
     107 |     const issues = [];
     108 |     if (!profile.profile_name) issues.push({ level: 'blocked', text: 'Exact Ossiguard profile not selected' });
     109 |     if (!profile.connector_revision) issues.push({ level: 'blocked', text: 'Revision not identified' });
     110 |     if (!profile.attaches_to_component_uuid && !profile.attaches_to_component_label) issues.push({ level: 'blocked', text: 'Receiving prosthetic component not identified' });
     111 |     if (!profile.approved_contact_surfaces) issues.push({ level: 'warning', text: 'Attachment surface not documented as approved' });

=== src/services/projectService.js ===
      49 |   list: () =>
      50 |     adapters.database.list('CoverProject'),
      51 | 
      52 |   get: async uuid =>
      53 |     (
>>    54 |       await adapters.database.filter(
      55 |         'CoverProject',
      56 |         { uuid },
      57 |         '-updated_date',
      58 |         1
      59 |       )
      60 |     )[0],
      61 | 
      62 |   filter: query =>
      63 |     adapters.database.filter(
      64 |       'CoverProject',
      65 |       query
      66 |     ),
      67 | 
      68 |   async create(data, actor) {
      69 |     const {
      70 |       id,
      71 |       created_date,
      72 |       updated_date,
     114 |         'Combination'
     115 |       )
     116 |     ) {
     117 |       const limb =
     118 |         (
>>   119 |           await adapters.database.filter(
     120 |             'LimbProfile',
     121 |             {
     122 |               uuid: data.limb_profile_uuid,
     123 |             },
     124 |             '-updated_date',
     125 |             1
     126 |           )
     127 |         )[0];
     128 | 

=== src/services/prosthesisService.js ===
       1 | import { adapters } from '@/services/serviceConfig';
>>     2 | export const prosthesisService = { list: () => adapters.database.list('Prosthesis'), byCustomer: (customer_uuid) => adapters.database.filter('Prosthesis', { customer_uuid }) };

=== src/services/quoteService.js ===
       1 | import { adapters, migrationFields, newUuid } from '@/services/serviceConfig';
       2 | import { auditService } from '@/services/auditService';
       3 | export const quoteService = {
       4 |   list: () => adapters.database.list('Quote'),
>>     5 |   forProject: (project_uuid) => adapters.database.filter('Quote', { project_uuid }),
       6 |   forCustomer: (customer_uuid) => adapters.database.filter('Quote', { customer_uuid }),
       7 |   get: async (uuid) => (await adapters.database.filter('Quote', { uuid }, '-updated_date', 1))[0],
       8 |   async create(data, actor) { const record = await adapters.database.create('Quote', { ...data, uuid: newUuid('quote'), quote_number: `Q-${Date.now().toString().slice(-6)}`, approval_status: data.approval_status || 'Draft', data_origin: data.data_origin || 'Workshop Created', ...migrationFields(actor) }); await auditService.record('quote_created', 'Quote', record.uuid, `Created quote ${record.quote_number}`, actor); return record; },
       9 |   async update(id, uuid, data, actor) { const { id: _id, created_date, updated_date, created_by_id, ...editable } = data; const record = await adapters.database.update('Quote', id, { ...editable, updated_by_name: actor }); await auditService.record('quote_updated', 'Quote', uuid, 'Quote updated', actor); return record; },
      10 |   async approve(id, uuid, actor) { await adapters.database.update('Quote', id, { approval_status: 'Approved', updated_by_name: actor }); return auditService.record('quote_approved', 'Quote', uuid, 'Quote approved', actor); },
      11 |   async send(id, uuid, actor) { await adapters.database.update('Quote', id, { approval_status: 'Sent', sent_date: new Date().toISOString().slice(0, 10), updated_by_name: actor }); return auditService.record('quote_sent', 'Quote', uuid, 'Quote sent to customer', actor); },
      12 |   archive: async (record, actor) => { await adapters.database.archive('Quote', record.id); return auditService.record('quote_archived', 'Quote', record.uuid, 'Quote archived', actor); },
      13 |   restore: async (record, actor) => { await adapters.database.restore('Quote', record.id); return auditService.record('quote_restored', 'Quote', record.uuid, 'Quote restored', actor); },
      14 | };

=== src/services/serviceConfig.js ===
>>     1 | import { Base44DatabaseAdapter } from '@/adapters/Base44DatabaseAdapter';
       2 | import { Base44AuthAdapter } from '@/adapters/Base44AuthAdapter';
       3 | import { Base44FileStorageAdapter } from '@/adapters/Base44FileStorageAdapter';
       4 | import { Base44FunctionAdapter } from '@/adapters/Base44FunctionAdapter';
       5 | 
       6 | export const adapters = { database: Base44DatabaseAdapter, auth: Base44AuthAdapter, files: Base44FileStorageAdapter, functions: Base44FunctionAdapter };
       7 | const secureUuidV4 = () => {
       8 |   const cryptoApi = globalThis.crypto;
       9 | 
      10 |   if (
      11 |     cryptoApi
      12 |     && typeof cryptoApi.randomUUID === 'function'
      13 |   ) {
      14 |     return cryptoApi.randomUUID();
      15 |   }

=== src/services/shipmentService.js ===
       1 | import { adapters, migrationFields, newUuid } from '@/services/serviceConfig';
       2 | import { auditService } from '@/services/auditService';
       3 | export const shipmentService = {
       4 |   list: () => adapters.database.list('Shipment'),
>>     5 |   forOrder: (order_uuid) => adapters.database.filter('Shipment', { order_uuid }),
       6 |   forCustomer: (customer_uuid) => adapters.database.filter('Shipment', { customer_uuid }),
       7 |   get: async (uuid) => (await adapters.database.filter('Shipment', { uuid }, '-updated_date', 1))[0],
       8 |   async create(data, actor) { const record = await adapters.database.create('Shipment', { ...data, uuid: newUuid('ship'), shipment_reference: `SHP-${Date.now().toString().slice(-6)}`, status: data.status || 'Preparing', data_origin: data.data_origin || 'Workshop Created', ...migrationFields(actor) }); await auditService.record('shipment_created', 'Shipment', record.uuid, `Shipment ${record.shipment_reference} prepared`, actor); return record; },
       9 |   async dispatch(id, uuid, tracking, carrier, actor) { await adapters.database.update('Shipment', id, { tracking_number: tracking, carrier, status: 'Dispatched', dispatch_date: new Date().toISOString().slice(0, 10), updated_by_name: actor }); return auditService.record('shipment_dispatched', 'Shipment', uuid, `Dispatched via ${carrier} (${tracking})`, actor); },
      10 |   async deliver(id, uuid, actor) { await adapters.database.update('Shipment', id, { status: 'Delivered', delivered_date: new Date().toISOString().slice(0, 10), updated_by_name: actor }); return auditService.record('shipment_delivered', 'Shipment', uuid, 'Shipment delivered', actor); },
      11 | };

=== src/services/validationService.js ===
       1 | export const COSMETIC_BOUNDARY = 'Non-load-bearing cosmetic prosthetic cover only. It is not part of the prosthesis, must not support body weight, alter alignment, obstruct safety systems or replace any component. Manual review is required before printing.';
>>     2 | export const validationService = { projectWarnings: (p) => [!p.customer_uuid && 'Customer missing', !p.limb_profile_uuid && 'Limb profile missing', !p.safety_boundary_accepted && 'Safety declaration not accepted'].filter(Boolean) };

=== src/services/workshopService.js ===
       1 | import { adapters } from '@/services/serviceConfig';
       2 | // Aggregate counts used on customer cards and customer detail.
       3 | export const workshopService = {
       4 |   customerCounts: async (customer_uuid) => {
       5 |     const [limbs, projects, orders, covers] = await Promise.all([
>>     6 |       adapters.database.filter('LimbProfile', { customer_uuid }),
       7 |       adapters.database.filter('CoverProject', { customer_uuid }),
       8 |       adapters.database.filter('Order', { customer_uuid }),
       9 |       adapters.database.filter('CompletedCover', { customer_uuid }),
      10 |     ]);
      11 |     return { limbs: limbs.length, projects: projects.length, orders: orders.length, covers: covers.length };
      12 |   },
      13 |   isFictional: (record) => {
      14 |     const o = record && record.data_origin;
      15 |     return o === 'Fictional Test Data' || o === 'Fictional';
      16 |   },
      17 |   hideFictional: (records) => (records || []).filter((r) => !workshopService.isFictional(r)),
      18 | };

=== src/shire/localBase44Client.js ===
      40 |         sort,
      41 |         limit: String(limit),
      42 |       });
      43 | 
      44 |       const result = await request(
>>    45 |         `/collections/${encodeURIComponent(name)}?${params}`
      46 |       );
      47 | 
      48 |       return result.records || [];
      49 |     },
      50 | 
      51 |     async filter(query = {}, sort = '-updated_date', limit = 500) {
      52 |       const result = await request(
      53 |         `/collections/${encodeURIComponent(name)}/filter`,
      54 |         {
      55 |           method: 'POST',
      56 |           body: JSON.stringify({ query, sort, limit }),
      57 |         }
      58 |       );
      59 | 
      60 |       return result.records || [];
      61 |     },
      62 | 
      63 |     async get(id) {
      64 |       const result = await request(
>>    65 |         `/collections/${encodeURIComponent(name)}/${encodeURIComponent(id)}`
      66 |       );
      67 | 
      68 |       return result.record;
      69 |     },
      70 | 
      71 |     async create(data) {
      72 |       const result = await request(
      73 |         `/collections/${encodeURIComponent(name)}`,
      74 |         {
      75 |           method: 'POST',
      76 |           body: JSON.stringify(data || {}),
      77 |         }
      78 |       );
      79 | 
      80 |       return result.record;
      81 |     },
      82 | 
      83 |     async update(id, data) {
      84 |       const result = await request(
>>    85 |         `/collections/${encodeURIComponent(name)}/${encodeURIComponent(id)}`,
      86 |         {
      87 |           method: 'PATCH',
      88 |           body: JSON.stringify(data || {}),
      89 |         }
      90 |       );
      91 | 
      92 |       return result.record;
      93 |     },
      94 | 
      95 |     async delete(id) {
      96 |       const result = await request(
>>    97 |         `/collections/${encodeURIComponent(name)}/${encodeURIComponent(id)}`,
      98 |         {
      99 |           method: 'DELETE',
     100 |         }
     101 |       );
     102 | 
     103 |       return result;
     104 |     },
     105 | 
     106 |     async bulkCreate(records) {
     107 |       const result = await request(
>>   108 |         `/collections/${encodeURIComponent(name)}/bulk-create`,
     109 |         {
     110 |           method: 'POST',
     111 |           body: JSON.stringify({ records: records || [] }),
     112 |         }
     113 |       );
     114 | 
     115 |       return result.records || [];
     116 |     },
     117 | 
     178 |       `${feature} is not connected to a native SHiRE engine yet.`
     179 |     );
     180 |   };
     181 | }
     182 | 
>>   183 | export const base44 = {
     184 |   entities,
     185 | 
     186 |   auth: {
     187 |     me: async () => localUser,
     188 |     isAuthenticated: () => true,
     189 |     logout: () => {},
     190 |     redirectToLogin: () => {},
     191 |     loginViaEmailPassword: async () => localUser,
     192 |     loginWithProvider: async () => localUser,
     213 |       ),
     214 |     },
     215 |   },
     216 | };
     217 | 
>>   218 | export default base44;

------------------------------------------------------------
5. GATEWAY COLLECTION AND FILTER HANDLER
------------------------------------------------------------
      41 | )
      42 | 
      43 | MAX_JSON_BYTES = 8 * 1024 * 1024
      44 | MAX_UPLOAD_BYTES = 150 * 1024 * 1024
      45 | 
      46 | COLLECTION_RE = re.compile(r"^[A-Za-z][A-Za-z0-9_]{0,79}$")
      47 | 
>>    48 | ALLOWED_COLLECTIONS = {
      49 |     # LimbForge
      50 |     "AuditEvent",
      51 |     "CompletedCover",
      52 |     "Component",
      53 |     "CoverProject",
      54 |     "Customer",
      55 |     "EnvelopeStation",
      56 |     "ImplementationReport",
      57 |     "Invitation",
      58 |     "LimbProfile",
      59 |     "ManufacturingJob",
      60 |     "MeasurementDefinition",
      61 |     "MeasurementSession",
      62 |     "MeasurementValue",
      63 |     "Order",
      64 |     "OssiguardProfile",
      65 |     "Prosthesis",
      66 |     "Quote",
      67 |     "Shipment",
      68 |     "SystemSettings",
      69 |     "WorkshopAccount",
      70 | 
      71 |     # CoverCanvas
      72 |     "ArtworkAsset",
      73 |     "ArtworkLayer",
      74 |     "CoverCanvasProject",
      75 |     "CoverDesignVariant",
     159 |     ).encode("utf-8")
     160 | 
     161 | 
     162 | def normalise_collection(value: str) -> str:
     163 |     if not COLLECTION_RE.fullmatch(value):
     164 |         raise ValueError("Invalid collection name")
     165 | 
>>   166 |     if value not in ALLOWED_COLLECTIONS:
     167 |         raise ValueError(
     168 |             f"Collection is not enabled: {value}"
     169 |         )
     170 | 
     171 |     return value
     172 | 
     173 | 
     174 | def safe_relative_destination(value: str) -> Path:
     175 |     cleaned = unquote(value or "").strip().replace("\\", "/")
     176 |     cleaned = cleaned.lstrip("/")
     177 | 
     178 |     if cleaned.startswith("SHiRELimbs/"):
     179 |         cleaned = cleaned[len("SHiRELimbs/"):]
     420 | 
     421 |         return [
     422 |             unquote(part)
     423 |             for part in parsed.path.split("/")
     424 |             if part
     425 |         ]
     426 | 
>>   427 |     def do_GET(self) -> None:
     428 |         try:
     429 |             parsed = urlparse(self.path)
     430 |             parts = self._path_parts()
     431 | 
     432 |             if parsed.path == "/health":
     433 |                 self._send(
     434 |                     200,
     435 |                     {
     436 |                         "ok": True,
     437 |                         "service": (
     438 |                             "shire-limbforge-canvas-gateway"
     439 |                         ),
     440 |                         "version": VERSION,
     479 |                 return
     480 | 
     481 |             if (
     482 |                 len(parts) >= 4
     483 |                 and parts[:3] == [
     484 |                     "api",
     485 |                     "v1",
>>   486 |                     "collections",
     487 |                 ]
     488 |             ):
     489 |                 collection = normalise_collection(
     490 |                     parts[3]
     491 |                 )
     492 | 
     493 |                 if len(parts) == 4:
     494 |                     query_args = parse_qs(
     495 |                         parsed.query
     496 |                     )
     497 |                     sort_value = query_args.get(
     498 |                         "sort",
     499 |                         ["-updated_date"],
     598 |                             ),
     599 |                         },
     600 |                     )
     601 |                     return
     602 | 
     603 |             self._error(
     604 |                 404,
>>   605 |                 "Route not found",
     606 |             )
     607 | 
     608 |         except ValueError as exc:
     609 |             self._error(
     610 |                 400,
     611 |                 str(exc),
     612 |             )
     613 |         except Exception as exc:
     614 |             self._error(
     615 |                 500,
     616 |                 f"Internal error: {exc}",
     617 |             )
     618 | 
     619 |     def do_POST(self) -> None:
     620 |         try:
     621 |             parts = self._path_parts()
     622 | 
     623 |             if not self._authorised():
     624 |                 return
     625 | 
     626 |             if parts == [
     627 |                 "api",
     628 |                 "v1",
     629 |                 "files",
     630 |             ]:
     631 |                 try:
     632 |                     length = int(
     745 |                 return
     746 | 
     747 |             if (
     748 |                 len(parts) >= 5
     749 |                 and parts[:3] == [
     750 |                     "api",
     751 |                     "v1",
>>   752 |                     "collections",
     753 |                 ]
     754 |             ):
     755 |                 collection = normalise_collection(
     756 |                     parts[3]
     757 |                 )
     758 |                 operation = parts[4]
     759 |                 body = self._read_json()
     760 | 
     761 |                 if operation == "filter":
     762 |                     query = body.get(
     763 |                         "query",
     764 |                         {},
     765 |                     )
     885 |                     return
     886 | 
     887 |             if (
     888 |                 len(parts) == 4
     889 |                 and parts[:3] == [
     890 |                     "api",
     891 |                     "v1",
>>   892 |                     "collections",
     893 |                 ]
     894 |             ):
     895 |                 collection = normalise_collection(
     896 |                     parts[3]
     897 |                 )
     898 |                 body = self._read_json()
     899 | 
     900 |                 with WRITE_LOCK, connect() as connection:
     901 |                     record = self._create_record(
     902 |                         connection,
     903 |                         collection,
     904 |                         body,
     905 |                     )
     912 |                         "record": record,
     913 |                     },
     914 |                 )
     915 |                 return
     916 | 
     917 |             self._error(
     918 |                 404,
>>   919 |                 "Route not found",
     920 |             )
     921 | 
     922 |         except ValueError as exc:
     923 |             self._error(
     924 |                 400,
     925 |                 str(exc),
     926 |             )
     927 |         except Exception as exc:
     928 |             self._error(
     929 |                 500,
     930 |                 f"Internal error: {exc}",
     931 |             )
     932 | 
     933 |     def _create_record(
     934 |         self,
     935 |         connection: sqlite3.Connection,
     936 |         collection: str,
     937 |         body: dict[str, Any],
    1015 |                 return
    1016 | 
    1017 |             if not (
    1018 |                 len(parts) == 5
    1019 |                 and parts[:3] == [
    1020 |                     "api",
    1021 |                     "v1",
>>  1022 |                     "collections",
    1023 |                 ]
    1024 |             ):
    1025 |                 self._error(
    1026 |                     404,
    1027 |                     "Route not found",
    1028 |                 )
    1029 |                 return
    1030 | 
    1031 |             collection = normalise_collection(
    1032 |                 parts[3]
    1033 |             )
    1034 |             record_id = parts[4]
    1035 |             changes = self._read_json()
    1036 | 
    1037 |             with WRITE_LOCK, connect() as connection:
    1038 |                 row = connection.execute(
    1039 |                     """
    1040 |                     SELECT *
    1113 |                     "ok": True,
    1114 |                     "record": record,
    1115 |                 },
    1116 |             )
    1117 | 
    1118 |         except ValueError as exc:
    1119 |             self._error(
>>  1120 |                 400,
    1121 |                 str(exc),
    1122 |             )
    1123 |         except Exception as exc:
    1124 |             self._error(
    1125 |                 500,
    1126 |                 f"Internal error: {exc}",
    1127 |             )
    1128 | 
    1129 |     def do_DELETE(self) -> None:
    1130 |         try:
    1131 |             parts = self._path_parts()
    1132 | 
    1133 |             if not self._authorised():
    1134 |                 return
    1135 | 
    1136 |             if not (
    1137 |                 len(parts) == 5
    1138 |                 and parts[:3] == [
    1139 |                     "api",
    1140 |                     "v1",
>>  1141 |                     "collections",
    1142 |                 ]
    1143 |             ):
    1144 |                 self._error(
    1145 |                     404,
    1146 |                     "Route not found",
    1147 |                 )
    1148 |                 return
    1149 | 
    1150 |             collection = normalise_collection(
    1151 |                 parts[3]
    1152 |             )
    1153 |             record_id = parts[4]
    1154 | 
    1155 |             with WRITE_LOCK, connect() as connection:
    1156 |                 row = connection.execute(
    1157 |                     """
    1158 |                     SELECT id
    1159 |                     FROM records
    1206 |                     "ok": True,
    1207 |                     "deleted": record_id,
    1208 |                 },
    1209 |             )
    1210 | 
    1211 |         except ValueError as exc:
    1212 |             self._error(
>>  1213 |                 400,
    1214 |                 str(exc),
    1215 |             )
    1216 |         except Exception as exc:
    1217 |             self._error(
    1218 |                 500,
    1219 |                 f"Internal error: {exc}",
    1220 |             )
    1221 | 
    1222 | 
    1223 | def main() -> None:
    1224 |     if HOST != "127.0.0.1":
    1225 |         raise SystemExit(
    1226 |             "Refusing to bind outside 127.0.0.1"

------------------------------------------------------------
6. READ-ONLY COLLECTION PROBES
------------------------------------------------------------

>>> GET DesignConfiguration
HTTP_STATUS=400
JSON_TYPE=object KEYS=error,ok

>>> GET MeasurementDefinition
HTTP_STATUS=200
JSON_TYPE=object KEYS=ok,records

>>> GET MeasurementSession
HTTP_STATUS=200
JSON_TYPE=object KEYS=ok,records

>>> GET MeasurementValue
HTTP_STATUS=200
JSON_TYPE=object KEYS=ok,records

------------------------------------------------------------
7. SAFE FILTER-SHAPE PROBES
------------------------------------------------------------

>>> DesignConfiguration/filter
BODY_SHAPE={}
HTTP_STATUS=400
{
  "ok": false,
  "error": "Collection is not enabled: DesignConfiguration"
}

>>> DesignConfiguration/filter
BODY_SHAPE={"filter":{}}
HTTP_STATUS=400
{
  "ok": false,
  "error": "Collection is not enabled: DesignConfiguration"
}

>>> DesignConfiguration/filter
BODY_SHAPE={"filters":{}}
HTTP_STATUS=400
{
  "ok": false,
  "error": "Collection is not enabled: DesignConfiguration"
}

>>> DesignConfiguration/filter
BODY_SHAPE={"query":{}}
HTTP_STATUS=400
{
  "ok": false,
  "error": "Collection is not enabled: DesignConfiguration"
}

------------------------------------------------------------
8. RECENT 400 EVENTS
------------------------------------------------------------
Aug 04 17:03:51 Work python3[1565280]: 04/Aug/2026 17:03:51 - "POST /api/v1/collections/MeasurementSession HTTP/1.1" 201 -
Aug 04 17:03:51 Work python3[1663563]: limbforge 04/Aug/2026 17:03:51 "POST /api/v1/collections/MeasurementSession HTTP/1.1" 201 -
Aug 04 17:03:57 Work python3[1565280]: 04/Aug/2026 17:03:57 - "POST /api/v1/collections/MeasurementSession/filter HTTP/1.1" 200 -
Aug 04 17:03:57 Work python3[1663563]: limbforge 04/Aug/2026 17:03:57 "POST /api/v1/collections/MeasurementSession/filter HTTP/1.1" 200 -
Aug 04 17:03:57 Work python3[1565280]: 04/Aug/2026 17:03:57 - "POST /api/v1/collections/MeasurementValue/filter HTTP/1.1" 200 -
Aug 04 17:03:57 Work python3[1663563]: limbforge 04/Aug/2026 17:03:57 "POST /api/v1/collections/MeasurementValue/filter HTTP/1.1" 200 -
Aug 04 17:03:57 Work python3[1565280]: 04/Aug/2026 17:03:57 - "POST /api/v1/collections/DesignConfiguration/filter HTTP/1.1" 400 -
Aug 04 17:03:57 Work python3[1663563]: limbforge 04/Aug/2026 17:03:57 "POST /api/v1/collections/DesignConfiguration/filter HTTP/1.1" 400 -
Aug 04 17:03:57 Work python3[1565280]: 04/Aug/2026 17:03:57 - "POST /api/v1/collections/DesignConfiguration/filter HTTP/1.1" 400 -
Aug 04 17:03:57 Work python3[1663563]: limbforge 04/Aug/2026 17:03:57 "POST /api/v1/collections/DesignConfiguration/filter HTTP/1.1" 400 -
Aug 04 17:10:52 Work python3[1565280]: 04/Aug/2026 17:10:52 - "POST /api/v1/collections/MeasurementSession/filter HTTP/1.1" 200 -
Aug 04 17:10:52 Work python3[1663563]: limbforge 04/Aug/2026 17:10:52 "POST /api/v1/collections/MeasurementSession/filter HTTP/1.1" 200 -
Aug 04 17:10:52 Work python3[1565280]: 04/Aug/2026 17:10:52 - "POST /api/v1/collections/MeasurementValue/filter HTTP/1.1" 200 -
Aug 04 17:10:52 Work python3[1663563]: limbforge 04/Aug/2026 17:10:52 "POST /api/v1/collections/MeasurementValue/filter HTTP/1.1" 200 -
Aug 04 17:10:52 Work python3[1565280]: 04/Aug/2026 17:10:52 - "POST /api/v1/collections/DesignConfiguration/filter HTTP/1.1" 400 -
Aug 04 17:10:52 Work python3[1565280]: 04/Aug/2026 17:10:52 - "POST /api/v1/collections/DesignConfiguration/filter HTTP/1.1" 400 -
Aug 04 17:10:52 Work python3[1663563]: limbforge 04/Aug/2026 17:10:52 "POST /api/v1/collections/DesignConfiguration/filter HTTP/1.1" 400 -
Aug 04 17:10:52 Work python3[1663563]: limbforge 04/Aug/2026 17:10:52 "POST /api/v1/collections/DesignConfiguration/filter HTTP/1.1" 400 -
Aug 04 17:13:23 Work python3[1663563]: limbforge 04/Aug/2026 17:13:23 "GET /api/entities/MeasurementSession HTTP/1.1" 404 -
Aug 04 17:13:23 Work python3[1663563]: limbforge 04/Aug/2026 17:13:23 "GET /api/entities/MeasurementDefinition HTTP/1.1" 404 -
Aug 04 17:17:36 Work python3[1565280]: 04/Aug/2026 17:17:36 - "POST /api/v1/collections/DesignConfiguration/filter HTTP/1.1" 400 -
Aug 04 17:17:36 Work python3[1663563]: limbforge 04/Aug/2026 17:17:36 "POST /api/v1/collections/DesignConfiguration/filter HTTP/1.1" 400 -
Aug 04 17:17:36 Work python3[1663563]: limbforge 04/Aug/2026 17:17:36 "POST /api/v1/collections/DesignConfiguration/filter HTTP/1.1" 400 -
Aug 04 17:17:36 Work python3[1565280]: 04/Aug/2026 17:17:36 - "POST /api/v1/collections/DesignConfiguration/filter HTTP/1.1" 400 -
Aug 04 17:17:40 Work python3[1565280]: 04/Aug/2026 17:17:40 - "GET /api/v1/collections/MeasurementSession?sort=-updated_date&limit=500 HTTP/1.1" 200 -
Aug 04 17:17:40 Work python3[1663563]: limbforge 04/Aug/2026 17:17:40 "GET /api/v1/collections/MeasurementSession?sort=-updated_date&limit=500 HTTP/1.1" 200 -
Aug 04 17:27:47 Work python3[1565280]: 04/Aug/2026 17:27:47 - "GET /api/v1/collections/DesignConfiguration?sort=-updated_date&limit=3 HTTP/1.1" 400 -
Aug 04 17:27:47 Work python3[2093301]: limbforge 04/Aug/2026 17:27:47 "GET /api/v1/collections/DesignConfiguration?sort=-updated_date&limit=3 HTTP/1.1" 400 -
Aug 04 17:27:47 Work python3[1565280]: 04/Aug/2026 17:27:47 - "GET /api/v1/collections/MeasurementDefinition?sort=-updated_date&limit=3 HTTP/1.1" 200 -
Aug 04 17:27:47 Work python3[2093301]: limbforge 04/Aug/2026 17:27:47 "GET /api/v1/collections/MeasurementDefinition?sort=-updated_date&limit=3 HTTP/1.1" 200 -
Aug 04 17:27:47 Work python3[1565280]: 04/Aug/2026 17:27:47 - "GET /api/v1/collections/MeasurementSession?sort=-updated_date&limit=3 HTTP/1.1" 200 -
Aug 04 17:27:47 Work python3[2093301]: limbforge 04/Aug/2026 17:27:47 "GET /api/v1/collections/MeasurementSession?sort=-updated_date&limit=3 HTTP/1.1" 200 -
Aug 04 17:27:47 Work python3[1565280]: 04/Aug/2026 17:27:47 - "GET /api/v1/collections/MeasurementValue?sort=-updated_date&limit=3 HTTP/1.1" 200 -
Aug 04 17:27:47 Work python3[2093301]: limbforge 04/Aug/2026 17:27:47 "GET /api/v1/collections/MeasurementValue?sort=-updated_date&limit=3 HTTP/1.1" 200 -
Aug 04 17:27:47 Work python3[1565280]: 04/Aug/2026 17:27:47 - "POST /api/v1/collections/DesignConfiguration/filter HTTP/1.1" 400 -
Aug 04 17:27:47 Work python3[2093301]: limbforge 04/Aug/2026 17:27:47 "POST /api/v1/collections/DesignConfiguration/filter HTTP/1.1" 400 -
Aug 04 17:27:48 Work python3[1565280]: 04/Aug/2026 17:27:48 - "POST /api/v1/collections/DesignConfiguration/filter HTTP/1.1" 400 -
Aug 04 17:27:48 Work python3[2093301]: limbforge 04/Aug/2026 17:27:48 "POST /api/v1/collections/DesignConfiguration/filter HTTP/1.1" 400 -
Aug 04 17:27:48 Work python3[1565280]: 04/Aug/2026 17:27:48 - "POST /api/v1/collections/DesignConfiguration/filter HTTP/1.1" 400 -
Aug 04 17:27:48 Work python3[2093301]: limbforge 04/Aug/2026 17:27:48 "POST /api/v1/collections/DesignConfiguration/filter HTTP/1.1" 400 -
Aug 04 17:27:48 Work python3[1565280]: 04/Aug/2026 17:27:48 - "POST /api/v1/collections/DesignConfiguration/filter HTTP/1.1" 400 -
Aug 04 17:27:48 Work python3[2093301]: limbforge 04/Aug/2026 17:27:48 "POST /api/v1/collections/DesignConfiguration/filter HTTP/1.1" 400 -

============================================================
 AUDIT COMPLETE — NOTHING WAS CHANGED
============================================================
Evidence: /SHiREVault/Backup/OSBackups/LIMBFORGE-MEASUREMENT-STUDIO-FAULT-AUDIT-20260804T092747Z

No source, database or service configuration was modified.
No service was restarted.
Sentinel was not modified or restarted.