LIMBFORGE AUTHORITATIVE SCHEMA AND API MAP
============================================================================

SERVER DATABASE CREATION / MIGRATION CONTEXT
----------------------------------------------------------------------------
00018: ROOT = Path(__file__).resolve().parent
00019: STATIC = ROOT / "static"
00020: DATA = ROOT / "data"
00021: DATABASE = DATA / "limbforge.sqlite3"
00022: 
00023: DATABASE_LOCK = threading.Lock()
00024: 
00025: MEASUREMENTS = [
00026:     {
00027:         "key": "cosmetic_envelope_length",
00028:         "name": "Cosmetic envelope length",
00029:         "instruction": (
00030:             "Measure between the specialist-agreed proximal reference "
00031:             "and the intended distal end of the cosmetic cover."
00032:         ),
      ...
00142:         "focus": "oi-opening",
00143:         "oi_only": True,
00144:     },
00145: ]
00146: 
00147: MEASUREMENT_BY_KEY = {
00148:     item["key"]: item
00149:     for item in MEASUREMENTS
00150: }
00151: 
00152: 
00153: def utc_now() -> str:
00154:     return datetime.now(timezone.utc).isoformat(timespec="seconds")
00155: 
00156: 
00157: def connect() -> sqlite3.Connection:
00158:     connection = sqlite3.connect(DATABASE)
00159:     connection.row_factory = sqlite3.Row
00160:     connection.execute("PRAGMA foreign_keys = ON")
00161:     return connection
00162: 
00163: 
00164: def initialise_database() -> None:
00165:     DATA.mkdir(parents=True, exist_ok=True)
00166: 
00167:     with DATABASE_LOCK, connect() as database:
00168:         database.executescript(
00169:             """
00170:             CREATE TABLE IF NOT EXISTS projects (
00171:                 id TEXT PRIMARY KEY,
00172:                 name TEXT NOT NULL,
00173:                 reference_id TEXT NOT NULL DEFAULT '',
00174:                 side TEXT NOT NULL,
00175:                 cover_class TEXT NOT NULL,
00176:                 osseointegration INTEGER NOT NULL DEFAULT 0,
00177:                 specialist_name TEXT NOT NULL DEFAULT '',
      ...
00179:                 exclusion_zones TEXT NOT NULL DEFAULT '',
00180:                 component_notes TEXT NOT NULL DEFAULT '',
00181:                 review_notes TEXT NOT NULL DEFAULT '',
00182:                 created_at TEXT NOT NULL,
00183:                 updated_at TEXT NOT NULL
00184:             );
00185: 
00186:             CREATE TABLE IF NOT EXISTS measurements (
00187:                 project_id TEXT NOT NULL,
00188:                 measurement_key TEXT NOT NULL,
00189:                 value_mm REAL NOT NULL,
00190:                 notes TEXT NOT NULL DEFAULT '',
00191:                 status TEXT NOT NULL DEFAULT 'completed',
00192:                 updated_at TEXT NOT NULL,
00193:                 PRIMARY KEY (project_id, measurement_key),
00194:                 FOREIGN KEY (project_id)
00195:                     REFERENCES projects(id)
00196:                     ON DELETE CASCADE
00197:             );
00198:             """
00199:         )
00200: 
00201: 
00202: def row_to_project(
00203:     row: sqlite3.Row,
00204:     measurements: list[sqlite3.Row] | None = None,
00205: ) -> dict:
00206:     project = dict(row)
00207:     project["osseointegration"] = bool(project["osseointegration"])
00208: 
00209:     if measurements is not None:
00210:         project["measurements"] = {
00211:             item["measurement_key"]: {
00212:                 "value_mm": item["value_mm"],
00213:                 "notes": item["notes"],
00214:                 "status": item["status"],
00215:                 "updated_at": item["updated_at"],
00216:             }
00217:             for item in measurements
00218:         }
00219: 
00220:     return project
00221: 
00222: 
00223: def list_projects() -> list[dict]:
00224:     with DATABASE_LOCK, connect() as database:
00225:         rows = database.execute(
00226:             """
00227:             SELECT *
00228:             FROM projects
00229:             ORDER BY updated_at DESC
00230:             """
00231:         ).fetchall()
00232: 
00233:     return [row_to_project(row) for row in rows]
00234: 
00235: 
00236: def load_project(project_id: str) -> dict | None:
00237:     with DATABASE_LOCK, connect() as database:
00238:         project = database.execute(
00239:             "SELECT * FROM projects WHERE id = ?",
00240:             (project_id,),
00241:         ).fetchone()
00242: 
00243:         if project is None:
00244:             return None
00245: 
00246:         measurements = database.execute(
00247:             """
00248:             SELECT *
00249:             FROM measurements
00250:             WHERE project_id = ?
00251:             ORDER BY updated_at
00252:             """,
00253:             (project_id,),
00254:         ).fetchall()
00255: 
00256:     return row_to_project(project, measurements)
00257: 
00258: 
00259: def create_project(payload: dict) -> dict:
00260:     project_id = str(uuid.uuid4())
00261:     timestamp = utc_now()
00262: 
00263:     name = str(payload.get("name", "")).strip()
      ...
00274:         raise ValueError("Cover class is required.")
00275: 
00276:     oi = bool(payload.get("osseointegration", False))
00277: 
00278:     with DATABASE_LOCK, connect() as database:
00279:         database.execute(
00280:             """
00281:             INSERT INTO projects (
00282:                 id,
00283:                 name,
00284:                 reference_id,
00285:                 side,
00286:                 cover_class,
00287:                 osseointegration,
00288:                 specialist_name,
      ...
00341:     )
00342: 
00343:     timestamp = utc_now()
00344: 
00345:     with DATABASE_LOCK, connect() as database:
00346:         database.execute(
00347:             """
00348:             UPDATE projects
00349:             SET
00350:                 name = ?,
00351:                 reference_id = ?,
00352:                 side = ?,
00353:                 cover_class = ?,
00354:                 osseointegration = ?,
00355:                 specialist_name = ?,
      ...
00423: 
00424:     if definition is None:
00425:         raise ValueError("Unknown measurement.")
00426: 
00427:     if definition["oi_only"] and not project["osseointegration"]:
00428:         raise ValueError(
00429:             "This measurement is available only for "
00430:             "osseointegration projects."
00431:         )
00432: 
00433:     try:
00434:         value = float(payload.get("value_mm"))
00435:     except (TypeError, ValueError):
00436:         raise ValueError("Enter a valid measurement in millimetres.")
00437: 
      ...
00446:         raise ValueError("Invalid measurement status.")
00447: 
00448:     timestamp = utc_now()
00449: 
00450:     with DATABASE_LOCK, connect() as database:
00451:         database.execute(
00452:             """
00453:             INSERT INTO measurements (
00454:                 project_id,
00455:                 measurement_key,
00456:                 value_mm,
00457:                 notes,
00458:                 status,
00459:                 updated_at
00460:             )
      ...
00474:                 status,
00475:                 timestamp,
00476:             ),
00477:         )
00478: 
00479:         database.execute(
00480:             """
00481:             UPDATE projects
00482:             SET updated_at = ?
00483:             WHERE id = ?
00484:             """,
00485:             (timestamp, project_id),
00486:         )
00487: 
00488:     return load_project(project_id)
      ...
00499: 
00500:     if measurement_key not in MEASUREMENT_BY_KEY:
00501:         raise ValueError("Unknown measurement.")
00502: 
00503:     with DATABASE_LOCK, connect() as database:
00504:         database.execute(
00505:             """
00506:             DELETE FROM measurements
00507:             WHERE project_id = ?
00508:               AND measurement_key = ?
00509:             """,
00510:             (project_id, measurement_key),
00511:         )
00512: 
00513:         database.execute(
00514:             """
00515:             UPDATE projects
00516:             SET updated_at = ?
00517:             WHERE id = ?
00518:             """,
00519:             (utc_now(), project_id),
00520:         )
00521: 
00522:     return load_project(project_id)
      ...
00596:                         "service": "limbforge-shared-workspace",
00597:                         "database": str(DATABASE),
00598:                     }
00599:                 )
00600:                 return
00601: 
00602:             if path == "/api/definitions":
00603:                 self.send_json(MEASUREMENTS)
00604:                 return
00605: 
00606:             if path == "/api/projects":
00607:                 self.send_json(list_projects())
00608:                 return
00609: 
00610:             parts = [
00611:                 unquote(part)
00612:                 for part in path.strip("/").split("/")
00613:                 if part
00614:             ]
00615: 
00616:             if (
00617:                 len(parts) == 3
00618:                 and parts[0] == "api"
00619:                 and parts[1] == "projects"
00620:             ):
00621:                 project = load_project(parts[2])
00622: 
00623:                 if project is None:
00624:                     raise LookupError("Project not found.")
00625: 
00626:                 self.send_json(project)
      ...
00631:         except Exception as error:
00632:             self.handle_api_error(error)
00633: 
00634:     def do_POST(self) -> None:
00635:         path = urlparse(self.path).path
00636: 
00637:         try:
00638:             if path == "/api/projects":
00639:                 self.send_json(
00640:                     create_project(self.read_json()),
00641:                     HTTPStatus.CREATED,
00642:                 )
00643:                 return
00644: 
00645:             self.send_json(
      ...
00658:             if part
00659:         ]
00660: 
00661:         try:
00662:             if (
00663:                 len(parts) == 3
00664:                 and parts[0] == "api"
00665:                 and parts[1] == "projects"
00666:             ):
00667:                 self.send_json(
00668:                     update_project(
00669:                         parts[2],
00670:                         self.read_json(),
00671:                     )
00672:                 )
00673:                 return
00674: 
00675:             if (
00676:                 len(parts) == 5
00677:                 and parts[0] == "api"
00678:                 and parts[1] == "projects"
00679:                 and parts[3] == "measurements"
00680:             ):
00681:                 self.send_json(
00682:                     save_measurement(
00683:                         parts[2],
00684:                         parts[4],
00685:                         self.read_json(),
00686:                     )
      ...
00703:             if part
00704:         ]
00705: 
00706:         try:
00707:             if (
00708:                 len(parts) == 5
00709:                 and parts[0] == "api"
00710:                 and parts[1] == "projects"
00711:                 and parts[3] == "measurements"
00712:             ):
00713:                 self.send_json(
00714:                     delete_measurement(
00715:                         parts[2],
00716:                         parts[4],
00717:                     )
00718:                 )

SERVER PROJECT AND MEASUREMENT API CONTEXT
----------------------------------------------------------------------------
00015: from pathlib import Path
00016: from urllib.parse import unquote, urlparse
00017: 
00018: ROOT = Path(__file__).resolve().parent
00019: STATIC = ROOT / "static"
00020: DATA = ROOT / "data"
00021: DATABASE = DATA / "limbforge.sqlite3"
00022: 
00023: DATABASE_LOCK = threading.Lock()
00024: 
00025: MEASUREMENTS = [
00026:     {
00027:         "key": "cosmetic_envelope_length",
00028:         "name": "Cosmetic envelope length",
00029:         "instruction": (
00030:             "Measure between the specialist-agreed proximal reference "
00031:             "and the intended distal end of the cosmetic cover."
00032:         ),
00033:         "guide": "lf_guide_length.png",
00034:         "focus": "full",
00035:         "oi_only": False,
      ...
00137:         "instruction": (
00138:             "Record the confirmed width of the cleaning, inspection and "
00139:             "emergency-access opening."
00140:         ),
00141:         "guide": "lf_guide_oi.png",
00142:         "focus": "oi-opening",
00143:         "oi_only": True,
00144:     },
00145: ]
00146: 
00147: MEASUREMENT_BY_KEY = {
00148:     item["key"]: item
00149:     for item in MEASUREMENTS
00150: }
00151: 
00152: 
00153: def utc_now() -> str:
00154:     return datetime.now(timezone.utc).isoformat(timespec="seconds")
00155: 
00156: 
00157: def connect() -> sqlite3.Connection:
00158:     connection = sqlite3.connect(DATABASE)
00159:     connection.row_factory = sqlite3.Row
      ...
00166: 
00167:     with DATABASE_LOCK, connect() as database:
00168:         database.executescript(
00169:             """
00170:             CREATE TABLE IF NOT EXISTS projects (
00171:                 id TEXT PRIMARY KEY,
00172:                 name TEXT NOT NULL,
00173:                 reference_id TEXT NOT NULL DEFAULT '',
00174:                 side TEXT NOT NULL,
00175:                 cover_class TEXT NOT NULL,
00176:                 osseointegration INTEGER NOT NULL DEFAULT 0,
00177:                 specialist_name TEXT NOT NULL DEFAULT '',
00178:                 clinic_name TEXT NOT NULL DEFAULT '',
00179:                 exclusion_zones TEXT NOT NULL DEFAULT '',
00180:                 component_notes TEXT NOT NULL DEFAULT '',
00181:                 review_notes TEXT NOT NULL DEFAULT '',
00182:                 created_at TEXT NOT NULL,
00183:                 updated_at TEXT NOT NULL
00184:             );
00185: 
00186:             CREATE TABLE IF NOT EXISTS measurements (
00187:                 project_id TEXT NOT NULL,
00188:                 measurement_key TEXT NOT NULL,
00189:                 value_mm REAL NOT NULL,
00190:                 notes TEXT NOT NULL DEFAULT '',
00191:                 status TEXT NOT NULL DEFAULT 'completed',
00192:                 updated_at TEXT NOT NULL,
00193:                 PRIMARY KEY (project_id, measurement_key),
00194:                 FOREIGN KEY (project_id)
00195:                     REFERENCES projects(id)
00196:                     ON DELETE CASCADE
00197:             );
00198:             """
00199:         )
00200: 
00201: 
00202: def row_to_project(
00203:     row: sqlite3.Row,
00204:     measurements: list[sqlite3.Row] | None = None,
00205: ) -> dict:
00206:     project = dict(row)
00207:     project["osseointegration"] = bool(project["osseointegration"])
00208: 
00209:     if measurements is not None:
00210:         project["measurements"] = {
00211:             item["measurement_key"]: {
00212:                 "value_mm": item["value_mm"],
00213:                 "notes": item["notes"],
00214:                 "status": item["status"],
00215:                 "updated_at": item["updated_at"],
00216:             }
00217:             for item in measurements
00218:         }
00219: 
00220:     return project
00221: 
00222: 
00223: def list_projects() -> list[dict]:
00224:     with DATABASE_LOCK, connect() as database:
00225:         rows = database.execute(
00226:             """
00227:             SELECT *
      ...
00236: def load_project(project_id: str) -> dict | None:
00237:     with DATABASE_LOCK, connect() as database:
00238:         project = database.execute(
00239:             "SELECT * FROM projects WHERE id = ?",
00240:             (project_id,),
00241:         ).fetchone()
00242: 
00243:         if project is None:
00244:             return None
00245: 
00246:         measurements = database.execute(
00247:             """
00248:             SELECT *
00249:             FROM measurements
00250:             WHERE project_id = ?
00251:             ORDER BY updated_at
00252:             """,
00253:             (project_id,),
00254:         ).fetchall()
00255: 
00256:     return row_to_project(project, measurements)
00257: 
00258: 
00259: def create_project(payload: dict) -> dict:
00260:     project_id = str(uuid.uuid4())
00261:     timestamp = utc_now()
00262: 
00263:     name = str(payload.get("name", "")).strip()
00264:     side = str(payload.get("side", "")).strip()
00265:     cover_class = str(payload.get("cover_class", "")).strip()
00266: 
00267:     if not name:
00268:         raise ValueError("Project name is required.")
00269: 
00270:     if side not in {"Right", "Left", "Bilateral"}:
00271:         raise ValueError("Select Right, Left or Bilateral.")
00272: 
00273:     if not cover_class:
00274:         raise ValueError("Cover class is required.")
00275: 
00276:     oi = bool(payload.get("osseointegration", False))
00277: 
00278:     with DATABASE_LOCK, connect() as database:
00279:         database.execute(
00280:             """
00281:             INSERT INTO projects (
00282:                 id,
00283:                 name,
00284:                 reference_id,
00285:                 side,
00286:                 cover_class,
00287:                 osseointegration,
00288:                 specialist_name,
00289:                 clinic_name,
00290:                 exclusion_zones,
00291:                 component_notes,
00292:                 review_notes,
00293:                 created_at,
00294:                 updated_at
00295:             )
00296:             VALUES (?, ?, ?, ?, ?, ?, '', '', '', '', '', ?, ?)
00297:             """,
00298:             (
00299:                 project_id,
00300:                 name,
00301:                 str(payload.get("reference_id", "")).strip(),
00302:                 side,
      ...
00328: 
00329:     cover_class = str(
00330:         payload.get("cover_class", existing["cover_class"])
00331:     ).strip()
00332: 
00333:     if not cover_class:
00334:         raise ValueError("Cover class is required.")
00335: 
00336:     oi = bool(
00337:         payload.get(
00338:             "osseointegration",
00339:             existing["osseointegration"],
00340:         )
00341:     )
00342: 
00343:     timestamp = utc_now()
00344: 
00345:     with DATABASE_LOCK, connect() as database:
00346:         database.execute(
00347:             """
00348:             UPDATE projects
00349:             SET
00350:                 name = ?,
00351:                 reference_id = ?,
00352:                 side = ?,
00353:                 cover_class = ?,
00354:                 osseointegration = ?,
00355:                 specialist_name = ?,
00356:                 clinic_name = ?,
00357:                 exclusion_zones = ?,
00358:                 component_notes = ?,
00359:                 review_notes = ?,
00360:                 updated_at = ?
00361:             WHERE id = ?
00362:             """,
00363:             (
00364:                 name,
00365:                 str(
00366:                     payload.get(
00367:                         "reference_id",
00368:                         existing["reference_id"],
00369:                     )
      ...
00378:                     )
00379:                 ).strip(),
00380:                 str(
00381:                     payload.get(
00382:                         "clinic_name",
00383:                         existing["clinic_name"],
00384:                     )
00385:                 ).strip(),
00386:                 str(
00387:                     payload.get(
00388:                         "exclusion_zones",
00389:                         existing["exclusion_zones"],
00390:                     )
00391:                 ).strip(),
00392:                 str(
00393:                     payload.get(
00394:                         "component_notes",
00395:                         existing["component_notes"],
00396:                     )
00397:                 ).strip(),
00398:                 str(
00399:                     payload.get(
00400:                         "review_notes",
00401:                         existing["review_notes"],
00402:                     )
00403:                 ).strip(),
00404:                 timestamp,
00405:                 project_id,
00406:             ),
00407:         )
00408: 
00409:     return load_project(project_id)
00410: 
00411: 
00412: def save_measurement(
00413:     project_id: str,
00414:     measurement_key: str,
00415:     payload: dict,
00416: ) -> dict:
00417:     project = load_project(project_id)
00418: 
00419:     if project is None:
00420:         raise LookupError("Project not found.")
00421: 
00422:     definition = MEASUREMENT_BY_KEY.get(measurement_key)
00423: 
00424:     if definition is None:
00425:         raise ValueError("Unknown measurement.")
00426: 
00427:     if definition["oi_only"] and not project["osseointegration"]:
00428:         raise ValueError(
00429:             "This measurement is available only for "
00430:             "osseointegration projects."
00431:         )
00432: 
00433:     try:
00434:         value = float(payload.get("value_mm"))
00435:     except (TypeError, ValueError):
00436:         raise ValueError("Enter a valid measurement in millimetres.")
00437: 
00438:     if value <= 0 or value > 2000:
00439:         raise ValueError(
00440:             "Measurement must be greater than zero and below 2000 mm."
00441:         )
00442: 
00443:     status = str(payload.get("status", "completed"))
00444: 
00445:     if status not in {"completed", "specialist_review"}:
00446:         raise ValueError("Invalid measurement status.")
00447: 
00448:     timestamp = utc_now()
00449: 
00450:     with DATABASE_LOCK, connect() as database:
00451:         database.execute(
00452:             """
00453:             INSERT INTO measurements (
00454:                 project_id,
00455:                 measurement_key,
00456:                 value_mm,
00457:                 notes,
00458:                 status,
00459:                 updated_at
00460:             )
00461:             VALUES (?, ?, ?, ?, ?, ?)
00462:             ON CONFLICT(project_id, measurement_key)
00463:             DO UPDATE SET
00464:                 value_mm = excluded.value_mm,
00465:                 notes = excluded.notes,
00466:                 status = excluded.status,
00467:                 updated_at = excluded.updated_at
00468:             """,
00469:             (
00470:                 project_id,
00471:                 measurement_key,
00472:                 value,
00473:                 str(payload.get("notes", "")).strip(),
00474:                 status,
00475:                 timestamp,
00476:             ),
00477:         )
00478: 
00479:         database.execute(
00480:             """
00481:             UPDATE projects
00482:             SET updated_at = ?
00483:             WHERE id = ?
00484:             """,
00485:             (timestamp, project_id),
00486:         )
00487: 
00488:     return load_project(project_id)
00489: 
00490: 
00491: def delete_measurement(
00492:     project_id: str,
00493:     measurement_key: str,
00494: ) -> dict:
00495:     project = load_project(project_id)
00496: 
00497:     if project is None:
00498:         raise LookupError("Project not found.")
00499: 
00500:     if measurement_key not in MEASUREMENT_BY_KEY:
00501:         raise ValueError("Unknown measurement.")
00502: 
00503:     with DATABASE_LOCK, connect() as database:
00504:         database.execute(
00505:             """
00506:             DELETE FROM measurements
00507:             WHERE project_id = ?
00508:               AND measurement_key = ?
00509:             """,
00510:             (project_id, measurement_key),
00511:         )
00512: 
00513:         database.execute(
00514:             """
00515:             UPDATE projects
00516:             SET updated_at = ?
00517:             WHERE id = ?
00518:             """,
00519:             (utc_now(), project_id),
00520:         )
      ...
00593:                 self.send_json(
00594:                     {
00595:                         "status": "ok",
00596:                         "service": "limbforge-shared-workspace",
00597:                         "database": str(DATABASE),
00598:                     }
00599:                 )
00600:                 return
00601: 
00602:             if path == "/api/definitions":
00603:                 self.send_json(MEASUREMENTS)
00604:                 return
00605: 
00606:             if path == "/api/projects":
00607:                 self.send_json(list_projects())
00608:                 return
00609: 
00610:             parts = [
00611:                 unquote(part)
00612:                 for part in path.strip("/").split("/")
00613:                 if part
00614:             ]
00615: 
00616:             if (
      ...
00628: 
00629:             self.serve_static(path)
00630: 
00631:         except Exception as error:
00632:             self.handle_api_error(error)
00633: 
00634:     def do_POST(self) -> None:
00635:         path = urlparse(self.path).path
00636: 
00637:         try:
00638:             if path == "/api/projects":
00639:                 self.send_json(
00640:                     create_project(self.read_json()),
00641:                     HTTPStatus.CREATED,
00642:                 )
00643:                 return
00644: 
00645:             self.send_json(
00646:                 {"error": "Route not found."},
00647:                 HTTPStatus.NOT_FOUND,
00648:             )
      ...
00669:                         parts[2],
00670:                         self.read_json(),
00671:                     )
00672:                 )
00673:                 return
00674: 
00675:             if (
00676:                 len(parts) == 5
00677:                 and parts[0] == "api"
00678:                 and parts[1] == "projects"
00679:                 and parts[3] == "measurements"
00680:             ):
00681:                 self.send_json(
00682:                     save_measurement(
00683:                         parts[2],
00684:                         parts[4],
00685:                         self.read_json(),
00686:                     )
00687:                 )
00688:                 return
00689: 
00690:             self.send_json(
00691:                 {"error": "Route not found."},
00692:                 HTTPStatus.NOT_FOUND,
      ...
00701:             unquote(part)
00702:             for part in path.strip("/").split("/")
00703:             if part
00704:         ]
00705: 
00706:         try:
00707:             if (
00708:                 len(parts) == 5
00709:                 and parts[0] == "api"
00710:                 and parts[1] == "projects"
00711:                 and parts[3] == "measurements"
00712:             ):
00713:                 self.send_json(
00714:                     delete_measurement(
00715:                         parts[2],
00716:                         parts[4],
00717:                     )
00718:                 )
00719:                 return
00720: 
00721:             self.send_json(
00722:                 {"error": "Route not found."},
00723:                 HTTPStatus.NOT_FOUND,
00724:             )

FRONTEND PROJECT FORM AND PAYLOAD CONTEXT
----------------------------------------------------------------------------
00001: <!doctype html>
00002: <html lang="en">
00003: <head>
00004:     <meta charset="utf-8">
00005:     <meta
00006:         name="viewport"
00007:         content="width=device-width, initial-scale=1, viewport-fit=cover"
00008:     >
00009:     <meta name="theme-color" content="#090b10">
00010:     <title>LimbForge Measurement Studio</title>
00011: 
00012:     <style>
00013:         :root {
00014:             color-scheme: dark;
00015: 
00016:             --background: #090b10;
00017:             --surface: #11151d;
00018:             --raised: #1a202c;
00019:             --raised-2: #212a38;
      ...
00305:             font-size: 25px;
00306:             color: var(--green);
00307:         }
00308: 
00309:         .progress-card span {
00310:             color: var(--muted);
00311:             font-size: 12px;
00312:         }
00313: 
00314:         .measurement-grid {
00315:             display: grid;
00316:             grid-template-columns:
00317:                 repeat(auto-fit, minmax(250px, 1fr));
00318:             gap: 14px;
00319:         }
00320: 
00321:         .measurement-card {
00322:             display: grid;
00323:             grid-template-columns: 1fr auto;
00324:             gap: 10px;
00325:             min-height: 142px;
00326:             padding: 16px;
00327:             border-radius: 17px;
00328:             color: var(--text);
00329:             text-align: left;
00330:             background: var(--surface);
00331:             border: 1px solid var(--border);
00332:             box-shadow: var(--shadow);
00333:         }
00334: 
00335:         .measurement-card:hover,
00336:         .measurement-card.active {
00337:             border-color: var(--blue);
00338:             transform: translateY(-1px);
00339:         }
00340: 
00341:         .measurement-card h3 {
00342:             margin: 0 0 7px;
00343:             font-size: 16px;
00344:         }
00345: 
00346:         .measurement-card p {
00347:             margin: 0;
00348:             color: var(--muted);
00349:             font-size: 12px;
00350:             line-height: 1.45;
00351:         }
00352: 
00353:         .measurement-value {
00354:             margin-top: 14px;
00355:             color: var(--green);
00356:             font-size: 20px;
00357:             font-weight: 900;
00358:         }
00359: 
00360:         .status-dot {
00361:             width: 12px;
00362:             height: 12px;
      ...
00649: 
00650:             .hero {
00651:                 display: grid;
00652:             }
00653: 
00654:             .progress-card {
00655:                 width: 100%;
00656:             }
00657: 
00658:             .measurement-grid {
00659:                 grid-template-columns: 1fr;
00660:             }
00661: 
00662:             .measurement-card {
00663:                 min-height: 118px;
00664:             }
00665: 
00666:             .editor-panel {
00667:                 border-left: 0;
00668:             }
00669: 
00670:             .guide-window {
00671:                 height: 70vh;
      ...
00695: </head>
00696: 
00697: <body>
00698: <div class="app">
00699:     <header class="topbar">
00700:         <div class="brand">
00701:             <div class="brand-mark">LF</div>
00702:             <div>
00703:                 <h1>LimbForge</h1>
00704:                 <p>Shared Measurement Studio</p>
00705:             </div>
00706:         </div>
00707: 
00708:         <div class="status-pill">
00709:             LOCAL-FIRST • SPECIALIST REVIEW
00710:         </div>
00711:     </header>
00712: 
00713:     <div class="workspace">
      ...
00728:             </div>
00729: 
00730:             <div id="project-list" class="project-list"></div>
00731:         </aside>
00732: 
00733:         <main class="main-panel">
00734:             <div id="no-project-view">
00735:                 <section class="hero">
00736:                     <div>
00737:                         <div class="section-label">Measurement Studio</div>
00738:                         <h2>Create or select a project</h2>
00739:                         <p>
00740:                             Measurements entered on desktop or phone are
00741:                             stored in the same local LimbForge workspace.
00742:                         </p>
00743:                     </div>
00744:                 </section>
00745: 
00746:                 <div class="safety-banner">
00747:                     LimbForge records geometry for non-load-bearing cosmetic
00748:                     covers. It does not provide socket fitting, clinical
00749:                     approval or permission to manufacture.
      ...
00754:                 <section class="hero">
00755:                     <div>
00756:                         <div class="section-label">Active project</div>
00757:                         <h2 id="project-title"></h2>
00758:                         <p id="project-subtitle"></p>
00759:                     </div>
00760: 
00761:                     <div class="progress-card">
00762:                         <strong id="progress-value">0 / 0</strong>
00763:                         <span>measurements recorded</span>
00764:                     </div>
00765:                 </section>
00766: 
00767:                 <div class="safety-banner">
00768:                     Specialist review is required. Preserve component,
00769:                     cleaning, inspection and emergency access at all times.
00770:                 </div>
00771: 
00772:                 <section class="project-form">
      ...
00799:                                 <option>Knee disarticulation</option>
00800:                                 <option>Transfemoral / above-knee</option>
00801:                                 <option>Hip disarticulation</option>
00802:                                 <option>Upper limb</option>
00803:                                 <option>Custom cosmetic cover</option>
00804:                             </select>
00805:                         </label>
00806: 
00807:                         <label>
00808:                             Osseointegration
00809:                             <select id="project-oi">
00810:                                 <option value="false">
00811:                                     No — conventional prosthesis
00812:                                 </option>
00813:                                 <option value="true">
00814:                                     Yes — osseointegration
00815:                                 </option>
00816:                             </select>
00817:                         </label>
00818: 
00819:                         <label>
00820:                             Prosthetic specialist
00821:                             <input id="project-specialist" type="text">
00822:                         </label>
00823: 
      ...
00847:                             id="save-project-button"
00848:                             class="secondary-button"
00849:                             type="button"
00850:                         >
00851:                             SAVE PROJECT DETAILS
00852:                         </button>
00853:                     </div>
00854:                 </section>
00855: 
00856:                 <div class="section-label">Measurement checklist</div>
00857:                 <div id="measurement-grid" class="measurement-grid"></div>
00858:             </div>
00859:         </main>
00860: 
00861:         <aside class="editor-panel">
00862:             <div id="editor-empty" class="editor-empty">
00863:                 <div>
00864:                     <strong>Select a measurement card</strong><br>
00865:                     The exact guide, value and notes will open here.
00866:                 </div>
00867:             </div>
00868: 
00869:             <section id="editor" class="editor" hidden>
00870:                 <div class="section-label" id="editor-status">
00871:                     Missing measurement
00872:                 </div>
00873: 
00874:                 <h2 id="editor-title"></h2>
00875:                 <p id="editor-instruction" class="editor-intro"></p>
00876: 
00877:                 <div id="guide-window" class="guide-window full">
00878:                     <img id="guide-image" alt="">
00879:                 </div>
00880: 
00881:                 <div class="field-grid">
00882:                     <label>
00883:                         Measurement in millimetres
00884:                         <input
00885:                             id="measurement-value"
00886:                             type="number"
00887:                             min="0.1"
00888:                             max="2000"
00889:                             step="0.1"
00890:                             inputmode="decimal"
00891:                         >
00892:                     </label>
00893: 
00894:                     <label>
00895:                         Status
00896:                         <select id="measurement-status">
00897:                             <option value="completed">
00898:                                 Completed
00899:                             </option>
00900:                             <option value="specialist_review">
00901:                                 Specialist review required
00902:                             </option>
00903:                         </select>
00904:                     </label>
00905: 
00906:                     <label>
00907:                         Measurement notes
00908:                         <textarea
00909:                             id="measurement-notes"
00910:                             placeholder="Reference point, technique, specialist correction or question"
00911:                         ></textarea>
00912:                     </label>
00913:                 </div>
00914: 
00915:                 <div class="editor-actions">
00916:                     <button
00917:                         id="save-measurement-button"
00918:                         class="primary-button"
00919:                         type="button"
00920:                     >
00921:                         SAVE
00922:                     </button>
00923: 
00924:                     <button
00925:                         id="save-next-button"
00926:                         class="secondary-button"
00927:                         type="button"
00928:                     >
00929:                         SAVE & NEXT
00930:                     </button>
00931: 
00932:                     <button
00933:                         id="reset-measurement-button"
00934:                         class="danger-button wide"
00935:                         type="button"
00936:                     >
00937:                         RESET THIS MEASUREMENT
00938:                     </button>
00939:                 </div>
00940:             </section>
00941:         </aside>
00942:     </div>
00943: </div>
00944: 
00945: <dialog id="new-project-dialog">
00946:     <form id="new-project-form" class="dialog-content">
      ...
00978:                     <option>Knee disarticulation</option>
00979:                     <option>Transfemoral / above-knee</option>
00980:                     <option>Hip disarticulation</option>
00981:                     <option>Upper limb</option>
00982:                     <option>Custom cosmetic cover</option>
00983:                 </select>
00984:             </label>
00985: 
00986:             <label>
00987:                 Does this project involve osseointegration?
00988:                 <select id="new-project-oi">
00989:                     <option value="false">
00990:                         No — conventional prosthesis
00991:                     </option>
00992:                     <option value="true">
00993:                         Yes — osseointegration
00994:                     </option>
00995:                 </select>
00996:             </label>
00997:         </div>
00998: 
00999:         <div class="dialog-actions">
01000:             <button
01001:                 id="cancel-project-button"
01002:                 class="ghost-button"
      ...
01016: </dialog>
01017: 
01018: <div id="toast" class="toast"></div>
01019: 
01020: <script>
01021:     const state = {
01022:         projects: [],
01023:         definitions: [],
01024:         activeProject: null,
01025:         activeMeasurementKey: null,
01026:     };
01027: 
01028:     const elements = {
01029:         projectList: document.querySelector("#project-list"),
01030:         noProjectView: document.querySelector("#no-project-view"),
01031:         projectView: document.querySelector("#project-view"),
01032:         projectTitle: document.querySelector("#project-title"),
01033:         projectSubtitle: document.querySelector("#project-subtitle"),
01034:         progressValue: document.querySelector("#progress-value"),
01035:         measurementGrid: document.querySelector("#measurement-grid"),
01036: 
01037:         editorEmpty: document.querySelector("#editor-empty"),
01038:         editor: document.querySelector("#editor"),
01039:         editorStatus: document.querySelector("#editor-status"),
01040:         editorTitle: document.querySelector("#editor-title"),
01041:         editorInstruction: document.querySelector("#editor-instruction"),
01042:         guideWindow: document.querySelector("#guide-window"),
01043:         guideImage: document.querySelector("#guide-image"),
01044:         measurementValue: document.querySelector("#measurement-value"),
01045:         measurementStatus: document.querySelector("#measurement-status"),
01046:         measurementNotes: document.querySelector("#measurement-notes"),
01047: 
01048:         projectName: document.querySelector("#project-name"),
01049:         projectReference: document.querySelector("#project-reference"),
01050:         projectSide: document.querySelector("#project-side"),
01051:         projectCoverClass:
01052:             document.querySelector("#project-cover-class"),
01053:         projectOi: document.querySelector("#project-oi"),
01054:         projectSpecialist:
01055:             document.querySelector("#project-specialist"),
      ...
01098: 
01099:     function visibleDefinitions() {
01100:         if (!state.activeProject) {
01101:             return [];
01102:         }
01103: 
01104:         return state.definitions.filter((definition) => {
01105:             return (
01106:                 !definition.oi_only ||
01107:                 state.activeProject.osseointegration
01108:             );
01109:         });
01110:     }
01111: 
01112:     function selectedDefinition() {
01113:         return state.definitions.find(
01114:             (definition) =>
01115:                 definition.key === state.activeMeasurementKey
01116:         );
01117:     }
01118: 
01119:     function selectedMeasurement() {
01120:         return (
01121:             state.activeProject?.measurements?.[
01122:                 state.activeMeasurementKey
01123:             ] || null
01124:         );
01125:     }
01126: 
01127:     function renderProjects() {
01128:         elements.projectList.innerHTML = "";
01129: 
01130:         if (state.projects.length === 0) {
01131:             elements.projectList.innerHTML = `
01132:                 <div class="empty-projects">
01133:                     No projects yet.<br>
01134:                     Create the first LimbForge measurement project.
01135:                 </div>
01136:             `;
01137:             return;
01138:         }
01139: 
01140:         for (const project of state.projects) {
01141:             const button = document.createElement("button");
01142: 
01143:             button.type = "button";
      ...
01147:                 button.classList.add("active");
01148:             }
01149: 
01150:             button.innerHTML = `
01151:                 <strong>${escapeHtml(project.name)}</strong>
01152:                 <span>
01153:                     ${escapeHtml(project.side)}
01154:                     •
01155:                     ${escapeHtml(project.cover_class)}
01156:                     ${project.osseointegration ? " • OI" : ""}
01157:                 </span>
01158:             `;
01159: 
01160:             button.addEventListener("click", () => {
01161:                 openProject(project.id);
01162:             });
01163: 
01164:             elements.projectList.append(button);
01165:         }
      ...
01173: 
01174:         if (!project) {
01175:             closeEditor();
01176:             return;
01177:         }
01178: 
01179:         elements.projectTitle.textContent = project.name;
01180:         elements.projectSubtitle.textContent =
01181:             `${project.side} • ${project.cover_class}` +
01182:             (project.osseointegration
01183:                 ? " • Osseointegration safety workflow"
01184:                 : " • Conventional prosthesis");
01185: 
01186:         elements.projectName.value = project.name;
01187:         elements.projectReference.value = project.reference_id;
01188:         elements.projectSide.value = project.side;
01189:         elements.projectCoverClass.value = project.cover_class;
01190:         elements.projectOi.value =
01191:             String(project.osseointegration);
01192:         elements.projectSpecialist.value =
01193:             project.specialist_name;
01194:         elements.projectClinic.value = project.clinic_name;
01195:         elements.projectExclusion.value =
01196:             project.exclusion_zones;
01197:         elements.projectComponents.value =
01198:             project.component_notes;
01199:         elements.projectReview.value = project.review_notes;
01200: 
01201:         renderMeasurements();
01202:     }
01203: 
01204:     function renderMeasurements() {
01205:         const definitions = visibleDefinitions();
01206:         const measurements =
01207:             state.activeProject?.measurements || {};
01208: 
01209:         const recorded = definitions.filter(
01210:             (definition) => measurements[definition.key]
01211:         ).length;
01212: 
01213:         elements.progressValue.textContent =
01214:             `${recorded} / ${definitions.length}`;
01215: 
01216:         elements.measurementGrid.innerHTML = "";
01217: 
01218:         for (const definition of definitions) {
01219:             const measurement = measurements[definition.key];
01220:             const button = document.createElement("button");
01221: 
01222:             button.type = "button";
01223:             button.className = "measurement-card";
01224: 
01225:             if (definition.oi_only) {
01226:                 button.classList.add("oi-card");
01227:             }
01228: 
01229:             if (
01230:                 definition.key === state.activeMeasurementKey
01231:             ) {
01232:                 button.classList.add("active");
01233:             }
01234: 
01235:             const statusClass =
01236:                 measurement?.status === "specialist_review"
01237:                     ? "review"
01238:                     : measurement
01239:                         ? "completed"
01240:                         : "";
01241: 
01242:             const statusText =
01243:                 measurement?.status === "specialist_review"
01244:                     ? "Specialist review"
01245:                     : measurement
01246:                         ? "Completed"
01247:                         : "Missing";
01248: 
01249:             button.innerHTML = `
01250:                 <div>
01251:                     <h3>${escapeHtml(definition.name)}</h3>
01252:                     <p>${escapeHtml(statusText)}</p>
01253:                     <div class="measurement-value">
01254:                         ${
01255:                             measurement
01256:                                 ? `${formatNumber(
01257:                                     measurement.value_mm
01258:                                 )} mm`
01259:                                 : "ADD MEASUREMENT"
01260:                         }
01261:                     </div>
01262:                 </div>
01263: 
01264:                 <span class="status-dot ${statusClass}"></span>
01265:             `;
01266: 
01267:             button.addEventListener("click", () => {
01268:                 openMeasurement(definition.key);
01269:             });
01270: 
01271:             elements.measurementGrid.append(button);
01272:         }
01273:     }
01274: 
01275:     function openMeasurement(key) {
01276:         state.activeMeasurementKey = key;
01277: 
01278:         const definition = selectedDefinition();
01279:         const measurement = selectedMeasurement();
01280: 
01281:         if (!definition) {
01282:             return;
01283:         }
01284: 
01285:         elements.editorEmpty.hidden = true;
01286:         elements.editor.hidden = false;
01287: 
01288:         elements.editorTitle.textContent = definition.name;
01289:         elements.editorInstruction.textContent =
01290:             definition.instruction;
01291: 
01292:         elements.editorStatus.textContent =
01293:             measurement?.status === "specialist_review"
01294:                 ? "SPECIALIST REVIEW REQUIRED"
01295:                 : measurement
01296:                     ? "MEASUREMENT RECORDED"
01297:                     : "MISSING MEASUREMENT";
01298: 
01299:         elements.editorStatus.style.color =
01300:             measurement?.status === "specialist_review"
01301:                 ? "var(--amber)"
01302:                 : measurement
01303:                     ? "var(--green)"
01304:                     : "var(--muted)";
01305: 
01306:         elements.guideWindow.className =
01307:             `guide-window ${definition.focus}`;
01308: 
01309:         elements.guideImage.src =
01310:             `/guides/${definition.guide}`;
01311: 
01312:         elements.guideImage.alt =
01313:             `${definition.name} measurement guide`;
01314: 
01315:         elements.measurementValue.value =
01316:             measurement?.value_mm ?? "";
01317: 
01318:         elements.measurementStatus.value =
01319:             measurement?.status ?? "completed";
01320: 
01321:         elements.measurementNotes.value =
01322:             measurement?.notes ?? "";
01323: 
01324:         renderMeasurements();
01325: 
01326:         if (window.innerWidth <= 760) {
01327:             elements.editor.scrollIntoView({
01328:                 behavior: "smooth",
01329:                 block: "start",
01330:             });
01331:         }
01332:     }
01333: 
01334:     function closeEditor() {
01335:         state.activeMeasurementKey = null;
01336:         elements.editor.hidden = true;
01337:         elements.editorEmpty.hidden = false;
01338:     }
01339: 
01340:     async function loadProjects() {
01341:         state.projects = await request("/api/projects");
01342:         renderProjects();
01343:     }
01344: 
01345:     async function openProject(projectId) {
01346:         state.activeProject = await request(
01347:             `/api/projects/${projectId}`
01348:         );
01349: 
01350:         state.activeMeasurementKey = null;
01351: 
01352:         renderProjects();
01353:         renderProject();
01354:         closeEditor();
01355:     }
01356: 
01357:     async function createProject(event) {
01358:         event.preventDefault();
01359: 
01360:         const project = await request("/api/projects", {
01361:             method: "POST",
01362:             body: JSON.stringify({
01363:                 name:
01364:                     document.querySelector(
01365:                         "#new-project-name"
01366:                     ).value,
01367:                 reference_id:
01368:                     document.querySelector(
01369:                         "#new-project-reference"
01370:                     ).value,
01371:                 side:
01372:                     document.querySelector(
01373:                         "#new-project-side"
01374:                     ).value,
01375:                 cover_class:
01376:                     document.querySelector(
01377:                         "#new-project-cover-class"
01378:                     ).value,
01379:                 osseointegration:
01380:                     document.querySelector(
01381:                         "#new-project-oi"
01382:                     ).value === "true",
01383:             }),
01384:         });
01385: 
01386:         elements.newProjectDialog.close();
01387:         elements.newProjectForm.reset();
01388: 
      ...
01392:         showToast("LimbForge project created.");
01393:     }
01394: 
01395:     async function saveProject() {
01396:         if (!state.activeProject) {
01397:             return;
01398:         }
01399: 
01400:         state.activeProject = await request(
01401:             `/api/projects/${state.activeProject.id}`,
01402:             {
01403:                 method: "PUT",
01404:                 body: JSON.stringify({
01405:                     name: elements.projectName.value,
01406:                     reference_id:
01407:                         elements.projectReference.value,
01408:                     side: elements.projectSide.value,
01409:                     cover_class:
01410:                         elements.projectCoverClass.value,
01411:                     osseointegration:
01412:                         elements.projectOi.value === "true",
01413:                     specialist_name:
01414:                         elements.projectSpecialist.value,
01415:                     clinic_name:
01416:                         elements.projectClinic.value,
01417:                     exclusion_zones:
01418:                         elements.projectExclusion.value,
01419:                     component_notes:
01420:                         elements.projectComponents.value,
      ...
01422:                         elements.projectReview.value,
01423:                 }),
01424:             }
01425:         );
01426: 
01427:         await loadProjects();
01428:         renderProject();
01429: 
01430:         if (
01431:             state.activeMeasurementKey &&
01432:             !visibleDefinitions().some(
01433:                 (definition) =>
01434:                     definition.key ===
01435:                     state.activeMeasurementKey
01436:             )
01437:         ) {
01438:             closeEditor();
01439:         }
01440: 
01441:         showToast("Project details saved.");
01442:     }
01443: 
01444:     async function saveMeasurement(moveNext) {
01445:         const definition = selectedDefinition();
01446: 
01447:         if (!state.activeProject || !definition) {
01448:             return;
01449:         }
01450: 
01451:         const value = Number(
01452:             elements.measurementValue.value
01453:         );
01454: 
01455:         if (!Number.isFinite(value) || value <= 0) {
01456:             throw new Error(
01457:                 "Enter a measurement greater than zero."
01458:             );
01459:         }
01460: 
01461:         state.activeProject = await request(
01462:             `/api/projects/${state.activeProject.id}` +
01463:             `/measurements/${definition.key}`,
01464:             {
01465:                 method: "PUT",
01466:                 body: JSON.stringify({
01467:                     value_mm: value,
01468:                     notes: elements.measurementNotes.value,
01469:                     status: elements.measurementStatus.value,
01470:                 }),
01471:             }
01472:         );
01473: 
01474:         await loadProjects();
01475:         renderProject();
01476: 
01477:         if (moveNext) {
01478:             const definitions = visibleDefinitions();
      ...
01483:             const next =
01484:                 definitions[
01485:                     Math.min(
01486:                         currentIndex + 1,
01487:                         definitions.length - 1
01488:                     )
01489:                 ];
01490: 
01491:             if (next && next.key !== definition.key) {
01492:                 openMeasurement(next.key);
01493:                 showToast("Saved. Moving to the next measurement.");
01494:                 return;
01495:             }
01496:         }
01497: 
01498:         openMeasurement(definition.key);
01499:         showToast("Measurement saved.");
01500:     }
01501: 
01502:     async function resetMeasurement() {
01503:         const definition = selectedDefinition();
01504: 
01505:         if (
01506:             !state.activeProject ||
01507:             !definition ||
01508:             !selectedMeasurement()
01509:         ) {
01510:             return;
01511:         }
01512: 
01513:         const confirmed = window.confirm(
01514:             `Reset ${definition.name}?`
01515:         );
01516: 
01517:         if (!confirmed) {
01518:             return;
01519:         }
01520: 
01521:         state.activeProject = await request(
01522:             `/api/projects/${state.activeProject.id}` +
01523:             `/measurements/${definition.key}`,
01524:             {
01525:                 method: "DELETE",
01526:             }
01527:         );
01528: 
01529:         await loadProjects();
01530:         renderProject();
01531:         openMeasurement(definition.key);
01532: 
01533:         showToast("Measurement reset.");
01534:     }
01535: 
01536:     function formatNumber(value) {
01537:         const number = Number(value);
01538: 
01539:         return Number.isInteger(number)
01540:             ? String(number)
01541:             : number.toFixed(1);
01542:     }
      ...
01575:     );
01576: 
01577:     document
01578:         .querySelector("#save-project-button")
01579:         .addEventListener("click", () => {
01580:             saveProject().catch(reportError);
01581:         });
01582: 
01583:     document
01584:         .querySelector("#save-measurement-button")
01585:         .addEventListener("click", () => {
01586:             saveMeasurement(false).catch(reportError);
01587:         });
01588: 
01589:     document
01590:         .querySelector("#save-next-button")
01591:         .addEventListener("click", () => {
01592:             saveMeasurement(true).catch(reportError);
01593:         });
01594: 
01595:     document
01596:         .querySelector("#reset-measurement-button")
01597:         .addEventListener("click", () => {
01598:             resetMeasurement().catch(reportError);
01599:         });
01600: 
01601:     async function start() {
01602:         const [definitions] = await Promise.all([
01603:             request("/api/definitions"),
01604:             loadProjects(),
01605:         ]);
01606: 
01607:         state.definitions = definitions;