@openhi/constructs 0.0.140 → 0.0.141

package/lib/rest-api-lambda.handler.mjs

@@ -5637,13 +5637,17 @@ function parseDateSearchValue(raw) {
   return { prefix: "eq", value: raw };
 }
 function flatJsonbExtract(jsonbPath) {
-  const match = /^\$\.([A-Za-z_][A-Za-z0-9_]*)$/.exec(jsonbPath);
-  if (!match) {
-    throw new Error(
-      `Generic date predicate requires a flat top-level JSONPath like "$.fieldName"; received "${jsonbPath}".`
-    );
+  const topLevel = /^\$\.([A-Za-z_][A-Za-z0-9_]*)$/.exec(jsonbPath);
+  if (topLevel) {
+    return `resource->>'${topLevel[1]}'`;
+  }
+  const nested = /^\$\.([A-Za-z_][A-Za-z0-9_]*)\.([A-Za-z_][A-Za-z0-9_]*)$/.exec(jsonbPath);
+  if (nested) {
+    return `resource->'${nested[1]}'->>'${nested[2]}'`;
   }
-  return `resource->>'${match[1]}'`;
+  throw new Error(
+    `Generic date predicate requires a scalar JSONPath like "$.fieldName" or "$.field.subfield"; received "${jsonbPath}".`
+  );
 }
 function emitDatePredicate(opts) {
   const { jsonbPath, rawValue, paramName } = opts;
@@ -6051,6 +6055,53 @@ var APPOINTMENT_SEARCH_PARAMETERS = [
   { code: "slot", type: "reference", jsonbPath: "$.slot[*]" }
 ];
 
+// src/data/search/registry/encounter-search-parameters.ts
+var ENCOUNTER_SEARCH_PARAMETERS = [
+  { code: "status", type: "token", jsonbPath: "$.status" },
+  { code: "class", type: "token", jsonbPath: "$.class" },
+  { code: "type", type: "token", jsonbPath: "$.type[*]" },
+  { code: "subject", type: "reference", jsonbPath: "$.subject" },
+  { code: "patient", type: "reference", jsonbPath: "$.subject" },
+  {
+    code: "participant",
+    type: "reference",
+    jsonbPath: "$.participant[*].individual"
+  },
+  { code: "date", type: "date", jsonbPath: "$.period.start" },
+  {
+    code: "service-provider",
+    type: "reference",
+    jsonbPath: "$.serviceProvider"
+  },
+  { code: "appointment", type: "reference", jsonbPath: "$.appointment[*]" },
+  {
+    code: "episode-of-care",
+    type: "reference",
+    jsonbPath: "$.episodeOfCare[*]"
+  }
+];
+
+// src/data/search/registry/observation-search-parameters.ts
+var OBSERVATION_SEARCH_PARAMETERS = [
+  { code: "status", type: "token", jsonbPath: "$.status" },
+  { code: "category", type: "token", jsonbPath: "$.category[*]" },
+  { code: "code", type: "token", jsonbPath: "$.code" },
+  { code: "subject", type: "reference", jsonbPath: "$.subject" },
+  { code: "patient", type: "reference", jsonbPath: "$.subject" },
+  { code: "encounter", type: "reference", jsonbPath: "$.encounter" },
+  { code: "performer", type: "reference", jsonbPath: "$.performer[*]" },
+  { code: "date", type: "date", jsonbPath: "$.effectiveDateTime" },
+  {
+    code: "value-string",
+    type: "string",
+    jsonbPath: "$.valueString",
+    modifiers: ["exact", "contains", "missing", "not"]
+  },
+  { code: "identifier", type: "token", jsonbPath: "$.identifier[*]" },
+  { code: "based-on", type: "reference", jsonbPath: "$.basedOn[*]" },
+  { code: "part-of", type: "reference", jsonbPath: "$.partOf[*]" }
+];
+
 // src/data/search/registry/patient-search-parameters.ts
 var PATIENT_SEARCH_PARAMETERS = [
   { code: "gender", type: "token", jsonbPath: "$.gender" },
@@ -6088,10 +6139,39 @@ var PATIENT_SEARCH_PARAMETERS = [
   }
 ];
 
+// src/data/search/registry/procedure-search-parameters.ts
+var PROCEDURE_SEARCH_PARAMETERS = [
+  { code: "status", type: "token", jsonbPath: "$.status" },
+  { code: "category", type: "token", jsonbPath: "$.category" },
+  { code: "code", type: "token", jsonbPath: "$.code" },
+  { code: "subject", type: "reference", jsonbPath: "$.subject" },
+  { code: "patient", type: "reference", jsonbPath: "$.subject" },
+  { code: "encounter", type: "reference", jsonbPath: "$.encounter" },
+  {
+    code: "performer",
+    type: "reference",
+    jsonbPath: "$.performer[*].actor"
+  },
+  { code: "date", type: "date", jsonbPath: "$.performedDateTime" },
+  { code: "location", type: "reference", jsonbPath: "$.location" },
+  { code: "identifier", type: "token", jsonbPath: "$.identifier[*]" },
+  { code: "based-on", type: "reference", jsonbPath: "$.basedOn[*]" },
+  { code: "part-of", type: "reference", jsonbPath: "$.partOf[*]" },
+  { code: "reason-code", type: "token", jsonbPath: "$.reasonCode[*]" },
+  {
+    code: "reason-reference",
+    type: "reference",
+    jsonbPath: "$.reasonReference[*]"
+  }
+];
+
 // src/data/search/registry/resolver.ts
 var STATIC_SEARCH_PARAMETER_MAP = {
   Appointment: APPOINTMENT_SEARCH_PARAMETERS,
-  Patient: PATIENT_SEARCH_PARAMETERS
+  Encounter: ENCOUNTER_SEARCH_PARAMETERS,
+  Observation: OBSERVATION_SEARCH_PARAMETERS,
+  Patient: PATIENT_SEARCH_PARAMETERS,
+  Procedure: PROCEDURE_SEARCH_PARAMETERS
 };
 var defaultSearchParameterResolver = (resourceType, _tenantId) => STATIC_SEARCH_PARAMETER_MAP[resourceType] ?? [];
 function getRegisteredSearchParameters(resourceType) {
@@ -13707,353 +13787,108 @@ async function listEncountersOperation(params) {
   );
 }
 
-// src/data/operations/data/encounter/encounter-period-search-predicate.ts
-var PERIOD_SEARCH_PREFIXES = [
-  "gt",
-  "lt",
-  "ge",
-  "le",
-  "sa",
-  "eb"
-];
-function isPeriodSearchPrefix(s) {
-  return PERIOD_SEARCH_PREFIXES.includes(s);
-}
-var PERIOD_START = "resource->'period'->>'start'";
-var PERIOD_END = "resource->'period'->>'end'";
-var HAS_ANY_BOUND_GUARD = `(${PERIOD_START} IS NOT NULL OR ${PERIOD_END} IS NOT NULL)`;
-function buildSinglePredicateSql(prefix, paramName) {
-  switch (prefix) {
-    case "gt":
-      return `(${PERIOD_END} IS NULL OR ${PERIOD_END} > :${paramName})`;
-    case "lt":
-      return `(${PERIOD_START} IS NULL OR ${PERIOD_START} < :${paramName})`;
-    case "ge":
-      return `(${PERIOD_END} IS NULL OR ${PERIOD_END} >= :${paramName})`;
-    case "le":
-      return `(${PERIOD_START} IS NULL OR ${PERIOD_START} <= :${paramName})`;
-    case "sa":
-      return `(${PERIOD_START} IS NOT NULL AND ${PERIOD_START} > :${paramName})`;
-    case "eb":
-      return `(${PERIOD_END} IS NOT NULL AND ${PERIOD_END} < :${paramName})`;
-  }
-}
-function periodConstraintParamName(index) {
-  return `periodConstraint${index}`;
-}
-function buildPeriodSearchPredicateSql(constraints) {
-  if (constraints.length === 0) {
-    return [];
-  }
-  const fragments = constraints.map(
-    (c, i) => buildSinglePredicateSql(c.prefix, periodConstraintParamName(i))
-  );
-  fragments.push(HAS_ANY_BOUND_GUARD);
-  return fragments;
-}
-function buildPeriodSearchPredicateParams(constraints) {
-  return constraints.map((c, i) => ({
-    name: periodConstraintParamName(i),
-    value: c.value
-  }));
-}
-
-// src/data/operations/data/encounter/encounter-search-by-date-operation.ts
-var DEFAULT_LIMIT2 = 100;
-function buildSearchEncountersByDateSql(opts) {
-  const periodPredicates = buildPeriodSearchPredicateSql(
-    opts.periodConstraints
-  );
-  const lines = [
-    "SELECT resource_id AS id, resource",
-    "FROM resources",
-    "WHERE tenant_id = :tenantId",
-    "  AND workspace_id = :workspaceId",
-    "  AND resource_type = 'Encounter'",
-    "  AND deleted_at IS NULL"
-  ];
-  for (const fragment of periodPredicates) {
-    lines.push(`  AND ${fragment}`);
-  }
-  lines.push("ORDER BY last_updated DESC");
-  lines.push("LIMIT :limit;");
-  return lines.join("\n");
-}
-async function searchEncountersByDateOperation(params) {
-  const { context, periodConstraints } = params;
-  if (periodConstraints.length === 0) {
-    throw new Error(
-      "searchEncountersByDateOperation requires at least one periodConstraint"
-    );
-  }
-  const { tenantId, workspaceId } = context;
-  const runner = params.runner ?? getDefaultPostgresQueryRunner();
-  const limit = params.limit ?? DEFAULT_LIMIT2;
-  const sql = buildSearchEncountersByDateSql({ periodConstraints });
-  const queryParams = [
-    { name: "tenantId", value: tenantId },
-    { name: "workspaceId", value: workspaceId },
-    { name: "limit", value: limit },
-    ...buildPeriodSearchPredicateParams(periodConstraints)
-  ];
-  const rows = await runner.query(sql, queryParams);
-  const entries = rows.map((row) => ({
-    id: row.id,
-    resource: {
-      ...row.resource,
-      id: row.id
-    }
-  }));
-  return { entries, total: entries.length };
+// src/data/rest-api/routes/data/encounter/encounter-list-route.ts
+var ENCOUNTER_RESOURCE_TYPE = "Encounter";
+function stripModifier2(key) {
+  const idx = key.indexOf(":");
+  return idx === -1 ? key : key.slice(0, idx);
 }
-
-// src/data/operations/data/encounter/encounter-search-by-participant-operation.ts
-var DEFAULT_LIMIT3 = 100;
-function buildSearchEncountersByParticipantSql(opts) {
-  const periodPredicates = buildPeriodSearchPredicateSql(
-    opts?.periodConstraints ?? []
-  );
-  const lines = [
-    "SELECT resource_id AS id, resource",
-    "FROM resources",
-    "WHERE tenant_id = :tenantId",
-    "  AND workspace_id = :workspaceId",
-    "  AND resource_type = 'Encounter'",
-    "  AND deleted_at IS NULL",
-    `  AND ${REFERENCE_CONTAINMENT_SQL_FRAGMENT}`
-  ];
-  for (const fragment of periodPredicates) {
-    lines.push(`  AND ${fragment}`);
-  }
-  lines.push("ORDER BY last_updated DESC");
-  lines.push("LIMIT :limit;");
-  return lines.join("\n");
+function isResultParameter2(key) {
+  return key.startsWith("_");
 }
-async function searchEncountersByParticipantOperation(params) {
-  const { context, participantReference } = params;
-  const periodConstraints = params.periodConstraints ?? [];
-  const { tenantId, workspaceId } = context;
-  const runner = params.runner ?? getDefaultPostgresQueryRunner();
-  const limit = params.limit ?? DEFAULT_LIMIT3;
-  const { containmentRelative, containmentUrn } = buildReferenceContainmentPayload({
-    shape: {
-      kind: "array-of-objects",
-      field: "participant",
-      subfield: "individual"
-    },
-    reference: participantReference,
-    tenantId,
-    workspaceId
+function sendInvalidSearch4002(res, diagnostics) {
+  return res.status(400).json({
+    resourceType: "OperationOutcome",
+    issue: [{ severity: "error", code: "invalid", diagnostics }]
   });
-  const sql = buildSearchEncountersByParticipantSql({ periodConstraints });
-  const queryParams = [
-    { name: "tenantId", value: tenantId },
-    { name: "workspaceId", value: workspaceId },
-    { name: "containmentRelative", value: containmentRelative },
-    { name: "containmentUrn", value: containmentUrn },
-    { name: "limit", value: limit },
-    ...buildPeriodSearchPredicateParams(periodConstraints)
-  ];
-  const rows = await runner.query(sql, queryParams);
-  const entries = rows.map((row) => ({
-    id: row.id,
-    resource: {
-      ...row.resource,
-      id: row.id
-    }
-  }));
-  return { entries, total: entries.length };
 }
-
-// src/data/operations/data/encounter/encounter-search-by-patient-operation.ts
-var DEFAULT_LIMIT4 = 100;
-function buildSearchEncountersByPatientSql(opts) {
-  const periodPredicates = buildPeriodSearchPredicateSql(
-    opts?.periodConstraints ?? []
-  );
-  const lines = [
-    "SELECT resource_id AS id, resource",
-    "FROM resources",
-    "WHERE tenant_id = :tenantId",
-    "  AND workspace_id = :workspaceId",
-    "  AND resource_type = 'Encounter'",
-    "  AND deleted_at IS NULL",
-    "  AND (resource @> :containmentRelative::jsonb",
-    "    OR resource @> :containmentUrn::jsonb)"
-  ];
-  for (const fragment of periodPredicates) {
-    lines.push(`  AND ${fragment}`);
-  }
-  lines.push("ORDER BY last_updated DESC");
-  lines.push("LIMIT :limit;");
-  return lines.join("\n");
-}
-async function searchEncountersByPatientOperation(params) {
-  const { context, patientId } = params;
-  const periodConstraints = params.periodConstraints ?? [];
-  const { tenantId, workspaceId } = context;
-  const runner = params.runner ?? getDefaultPostgresQueryRunner();
-  const limit = params.limit ?? DEFAULT_LIMIT4;
-  const containmentRelative = JSON.stringify({
-    subject: { reference: `Patient/${patientId}` }
-  });
-  const containmentUrn = JSON.stringify({
-    subject: {
-      reference: buildOpenHiResourceUrn({
-        tenantId,
-        workspaceId,
-        resourceType: "Patient",
-        resourceId: patientId
-      })
-    }
-  });
-  const sql = buildSearchEncountersByPatientSql({ periodConstraints });
-  const queryParams = [
-    { name: "tenantId", value: tenantId },
-    { name: "workspaceId", value: workspaceId },
-    { name: "containmentRelative", value: containmentRelative },
-    { name: "containmentUrn", value: containmentUrn },
-    { name: "limit", value: limit },
-    ...buildPeriodSearchPredicateParams(periodConstraints)
-  ];
-  const rows = await runner.query(sql, queryParams);
-  const entries = rows.map((row) => ({
-    id: row.id,
-    resource: {
-      ...row.resource,
-      id: row.id
+function extractSearchParamKeys2(query) {
+  const out = [];
+  for (const rawKey of Object.keys(query)) {
+    if (isResultParameter2(rawKey)) {
+      continue;
     }
-  }));
-  return { entries, total: entries.length };
-}
-
-// src/data/rest-api/routes/data/encounter/encounter-list-route.ts
-function singleStringQueryParam(req, name) {
-  const v = req.query[name];
-  if (typeof v !== "string") {
-    return void 0;
+    out.push({ rawKey, code: stripModifier2(rawKey) });
   }
-  const trimmed = v.trim();
-  return trimmed === "" ? void 0 : trimmed;
+  return out;
 }
-function isError(v) {
-  return v.error !== void 0;
+function buildUnknownParamDiagnostics2(unknownCodes) {
+  const validCodes = getRegisteredSearchParameters(ENCOUNTER_RESOURCE_TYPE).map((p) => p.code).sort().join(", ");
+  const codes = unknownCodes.join(", ");
+  const isPlural = unknownCodes.length !== 1;
+  return [
+    `Unknown search ${isPlural ? "parameters" : "parameter"} for Encounter: ${codes}.`,
+    `Valid codes: ${validCodes}.`
+  ].join(" ");
 }
-function parseEncounterDateConstraints(req) {
-  const raw = req.query.date;
-  if (raw === void 0) {
-    return [];
-  }
-  const values = Array.isArray(raw) ? raw : [raw];
-  const out = [];
-  for (const v of values) {
-    if (typeof v !== "string") {
-      return { error: "Each ?date= value must be a string." };
-    }
-    const trimmed = v.trim();
-    if (trimmed === "") {
-      return { error: "?date= value must not be empty." };
-    }
-    const prefix = trimmed.slice(0, 2);
-    const datetime = trimmed.slice(2);
-    if (!isPeriodSearchPrefix(prefix)) {
-      return {
-        error: `Unsupported ?date= prefix in "${trimmed}". Supported prefixes: ${PERIOD_SEARCH_PREFIXES.join(", ")}.`
-      };
+function findMalformedReference2(query, searchParamKeys) {
+  const referenceCodes = new Set(
+    getRegisteredSearchParameters(ENCOUNTER_RESOURCE_TYPE).filter((p) => p.type === "reference").map((p) => p.code)
+  );
+  for (const { rawKey, code } of searchParamKeys) {
+    if (!referenceCodes.has(code)) {
+      continue;
     }
-    if (datetime === "" || Number.isNaN(Date.parse(datetime))) {
-      return { error: `Invalid datetime in ?date=${trimmed}.` };
+    const raw = query[rawKey];
+    const values = typeof raw === "string" ? raw.split(",") : Array.isArray(raw) ? raw.flatMap((v) => v.split(",")) : [];
+    for (const v of values) {
+      const trimmed = v.trim();
+      if (trimmed.length === 0) {
+        continue;
+      }
+      if (parseTypedReference(trimmed) === void 0) {
+        return { rawKey, value: trimmed };
+      }
     }
-    out.push({ prefix, value: datetime });
   }
-  return out;
-}
-function sendInvalidSearch4002(res, diagnostics) {
-  return res.status(400).json({
-    resourceType: "OperationOutcome",
-    issue: [{ severity: "error", code: "invalid", diagnostics }]
-  });
+  return void 0;
 }
 async function listEncountersRoute(req, res) {
-  const patientId = singleStringQueryParam(req, "patient");
-  const participantRef = singleStringQueryParam(req, "participant");
-  const parsed = parseEncounterDateConstraints(req);
-  if (isError(parsed)) {
-    return sendInvalidSearch4002(res, parsed.error);
-  }
-  const periodConstraints = parsed;
-  if (patientId !== void 0 && participantRef !== void 0) {
+  const searchParamKeys = extractSearchParamKeys2(
+    req.query
+  );
+  if (searchParamKeys.length === 0) {
+    return handleListRoute({
+      req,
+      res,
+      basePath: BASE_PATH.ENCOUNTER,
+      listOperation: listEncountersOperation,
+      errorLogContext: "GET /Encounter list error:"
+    });
+  }
+  const registered = getRegisteredSearchParameters(ENCOUNTER_RESOURCE_TYPE);
+  const validCodes = new Set(registered.map((p) => p.code));
+  const unknownCodes = searchParamKeys.map((k) => k.code).filter((code) => !validCodes.has(code));
+  if (unknownCodes.length > 0) {
     return sendInvalidSearch4002(
       res,
-      "?patient= and ?participant= cannot be combined on the same request."
+      buildUnknownParamDiagnostics2([...new Set(unknownCodes)])
     );
   }
-  if (participantRef !== void 0) {
-    if (parseTypedReference(participantRef) === void 0) {
-      return sendInvalidSearch4002(
-        res,
-        `?participant must be a typed reference like "Practitioner/<id>"; got "${participantRef}".`
-      );
-    }
-    const ctx = req.openhiContext;
-    try {
-      const result = await searchEncountersByParticipantOperation({
-        context: ctx,
-        participantReference: participantRef,
-        periodConstraints
-      });
-      const bundle = buildSearchsetBundle(BASE_PATH.ENCOUNTER, result.entries);
-      return res.json(bundle);
-    } catch (err) {
-      return sendOperationOutcome500(
-        res,
-        err,
-        "GET /Encounter?participant= search error:"
-      );
-    }
-  }
-  if (patientId !== void 0) {
-    const ctx = req.openhiContext;
-    try {
-      const result = await searchEncountersByPatientOperation({
-        context: ctx,
-        patientId,
-        periodConstraints
-      });
-      const bundle = buildSearchsetBundle(BASE_PATH.ENCOUNTER, result.entries);
-      return res.json(bundle);
-    } catch (err) {
-      return sendOperationOutcome500(
-        res,
-        err,
-        "GET /Encounter?patient= search error:"
-      );
-    }
+  const malformedRef = findMalformedReference2(
+    req.query,
+    searchParamKeys
+  );
+  if (malformedRef !== void 0) {
+    return sendInvalidSearch4002(
+      res,
+      `?${malformedRef.rawKey} must be a typed reference like "Practitioner/<id>"; got "${malformedRef.value}".`
+    );
   }
-  if (periodConstraints.length > 0) {
-    const ctx = req.openhiContext;
-    try {
-      const result = await searchEncountersByDateOperation({
-        context: ctx,
-        periodConstraints
-      });
-      const bundle = buildSearchsetBundle(BASE_PATH.ENCOUNTER, result.entries);
-      return res.json(bundle);
-    } catch (err) {
-      return sendOperationOutcome500(
-        res,
-        err,
-        "GET /Encounter?date= search error:"
-      );
-    }
+  const ctx = req.openhiContext;
+  try {
+    const result = await genericSearchOperation({
+      resourceType: ENCOUNTER_RESOURCE_TYPE,
+      tenantId: ctx.tenantId,
+      workspaceId: ctx.workspaceId,
+      query: req.query,
+      resolver: defaultSearchParameterResolver
+    });
+    const bundle = buildSearchsetBundle(BASE_PATH.ENCOUNTER, result.entries);
+    return res.json(bundle);
+  } catch (err) {
+    return sendOperationOutcome500(res, err, "GET /Encounter search error:");
   }
-  return handleListRoute({
-    req,
-    res,
-    basePath: BASE_PATH.ENCOUNTER,
-    listOperation: listEncountersOperation,
-    errorLogContext: "GET /Encounter list error:"
-  });
 }
 
 // src/data/operations/data/encounter/encounter-update-operation.ts
@@ -24733,15 +24568,108 @@ async function listObservationsOperation(params) {
 }
 
 // src/data/rest-api/routes/data/observation/observation-list-route.ts
-async function listObservationsRoute(req, res) {
-  return handleListRoute({
-    req,
-    res,
-    basePath: BASE_PATH.OBSERVATION,
-    listOperation: listObservationsOperation,
-    errorLogContext: "GET /Observation list error:"
+var OBSERVATION_RESOURCE_TYPE = "Observation";
+function stripModifier3(key) {
+  const idx = key.indexOf(":");
+  return idx === -1 ? key : key.slice(0, idx);
+}
+function isResultParameter3(key) {
+  return key.startsWith("_");
+}
+function sendInvalidSearch4003(res, diagnostics) {
+  return res.status(400).json({
+    resourceType: "OperationOutcome",
+    issue: [{ severity: "error", code: "invalid", diagnostics }]
   });
 }
+function extractSearchParamKeys3(query) {
+  const out = [];
+  for (const rawKey of Object.keys(query)) {
+    if (isResultParameter3(rawKey)) {
+      continue;
+    }
+    out.push({ rawKey, code: stripModifier3(rawKey) });
+  }
+  return out;
+}
+function buildUnknownParamDiagnostics3(unknownCodes) {
+  const validCodes = getRegisteredSearchParameters(OBSERVATION_RESOURCE_TYPE).map((p) => p.code).sort().join(", ");
+  const codes = unknownCodes.join(", ");
+  const isPlural = unknownCodes.length !== 1;
+  return [
+    `Unknown search ${isPlural ? "parameters" : "parameter"} for Observation: ${codes}.`,
+    `Valid codes: ${validCodes}.`
+  ].join(" ");
+}
+function findMalformedReference3(query, searchParamKeys) {
+  const referenceCodes = new Set(
+    getRegisteredSearchParameters(OBSERVATION_RESOURCE_TYPE).filter((p) => p.type === "reference").map((p) => p.code)
+  );
+  for (const { rawKey, code } of searchParamKeys) {
+    if (!referenceCodes.has(code)) {
+      continue;
+    }
+    const raw = query[rawKey];
+    const values = typeof raw === "string" ? raw.split(",") : Array.isArray(raw) ? raw.flatMap((v) => v.split(",")) : [];
+    for (const v of values) {
+      const trimmed = v.trim();
+      if (trimmed.length === 0) {
+        continue;
+      }
+      if (parseTypedReference(trimmed) === void 0) {
+        return { rawKey, value: trimmed };
+      }
+    }
+  }
+  return void 0;
+}
+async function listObservationsRoute(req, res) {
+  const searchParamKeys = extractSearchParamKeys3(
+    req.query
+  );
+  if (searchParamKeys.length === 0) {
+    return handleListRoute({
+      req,
+      res,
+      basePath: BASE_PATH.OBSERVATION,
+      listOperation: listObservationsOperation,
+      errorLogContext: "GET /Observation list error:"
+    });
+  }
+  const registered = getRegisteredSearchParameters(OBSERVATION_RESOURCE_TYPE);
+  const validCodes = new Set(registered.map((p) => p.code));
+  const unknownCodes = searchParamKeys.map((k) => k.code).filter((code) => !validCodes.has(code));
+  if (unknownCodes.length > 0) {
+    return sendInvalidSearch4003(
+      res,
+      buildUnknownParamDiagnostics3([...new Set(unknownCodes)])
+    );
+  }
+  const malformedRef = findMalformedReference3(
+    req.query,
+    searchParamKeys
+  );
+  if (malformedRef !== void 0) {
+    return sendInvalidSearch4003(
+      res,
+      `?${malformedRef.rawKey} must be a typed reference like "Practitioner/<id>"; got "${malformedRef.value}".`
+    );
+  }
+  const ctx = req.openhiContext;
+  try {
+    const result = await genericSearchOperation({
+      resourceType: OBSERVATION_RESOURCE_TYPE,
+      tenantId: ctx.tenantId,
+      workspaceId: ctx.workspaceId,
+      query: req.query,
+      resolver: defaultSearchParameterResolver
+    });
+    const bundle = buildSearchsetBundle(BASE_PATH.OBSERVATION, result.entries);
+    return res.json(bundle);
+  } catch (err) {
+    return sendOperationOutcome500(res, err, "GET /Observation search error:");
+  }
+}
 
 // src/data/operations/data/observation/observation-update-operation.ts
 async function updateObservationOperation(params) {
@@ -25717,30 +25645,30 @@ async function listPatientsOperation(params) {
 
 // src/data/rest-api/routes/data/patient/patient-list-route.ts
 var PATIENT_RESOURCE_TYPE = "Patient";
-function stripModifier2(key) {
+function stripModifier4(key) {
   const idx = key.indexOf(":");
   return idx === -1 ? key : key.slice(0, idx);
 }
-function isResultParameter2(key) {
+function isResultParameter4(key) {
   return key.startsWith("_");
 }
-function sendInvalidSearch4003(res, diagnostics) {
+function sendInvalidSearch4004(res, diagnostics) {
   return res.status(400).json({
     resourceType: "OperationOutcome",
     issue: [{ severity: "error", code: "invalid", diagnostics }]
   });
 }
-function extractSearchParamKeys2(query) {
+function extractSearchParamKeys4(query) {
   const out = [];
   for (const rawKey of Object.keys(query)) {
-    if (isResultParameter2(rawKey)) {
+    if (isResultParameter4(rawKey)) {
       continue;
     }
-    out.push({ rawKey, code: stripModifier2(rawKey) });
+    out.push({ rawKey, code: stripModifier4(rawKey) });
   }
   return out;
 }
-function buildUnknownParamDiagnostics2(unknownCodes) {
+function buildUnknownParamDiagnostics4(unknownCodes) {
   const validCodes = getRegisteredSearchParameters(PATIENT_RESOURCE_TYPE).map((p) => p.code).sort().join(", ");
   const codes = unknownCodes.join(", ");
   const isPlural = unknownCodes.length !== 1;
@@ -25749,7 +25677,7 @@ function buildUnknownParamDiagnostics2(unknownCodes) {
     `Valid codes: ${validCodes}.`
   ].join(" ");
 }
-function findMalformedReference2(query, searchParamKeys) {
+function findMalformedReference4(query, searchParamKeys) {
   const referenceCodes = new Set(
     getRegisteredSearchParameters(PATIENT_RESOURCE_TYPE).filter((p) => p.type === "reference").map((p) => p.code)
   );
@@ -25772,7 +25700,7 @@ function findMalformedReference2(query, searchParamKeys) {
   return void 0;
 }
 async function listPatientsRoute(req, res) {
-  const searchParamKeys = extractSearchParamKeys2(
+  const searchParamKeys = extractSearchParamKeys4(
     req.query
   );
   if (searchParamKeys.length === 0) {
@@ -25788,17 +25716,17 @@ async function listPatientsRoute(req, res) {
   const validCodes = new Set(registered.map((p) => p.code));
   const unknownCodes = searchParamKeys.map((k) => k.code).filter((code) => !validCodes.has(code));
   if (unknownCodes.length > 0) {
-    return sendInvalidSearch4003(
+    return sendInvalidSearch4004(
       res,
-      buildUnknownParamDiagnostics2([...new Set(unknownCodes)])
+      buildUnknownParamDiagnostics4([...new Set(unknownCodes)])
     );
   }
-  const malformedRef = findMalformedReference2(
+  const malformedRef = findMalformedReference4(
     req.query,
     searchParamKeys
   );
   if (malformedRef !== void 0) {
-    return sendInvalidSearch4003(
+    return sendInvalidSearch4004(
       res,
       `?${malformedRef.rawKey} must be a typed reference like "Practitioner/<id>"; got "${malformedRef.value}".`
     );
@@ -27137,15 +27065,108 @@ async function listProceduresOperation(params) {
 }
 
 // src/data/rest-api/routes/data/procedure/procedure-list-route.ts
-async function listProceduresRoute(req, res) {
-  return handleListRoute({
-    req,
-    res,
-    basePath: BASE_PATH.PROCEDURE,
-    listOperation: listProceduresOperation,
-    errorLogContext: "GET /Procedure list error:"
+var PROCEDURE_RESOURCE_TYPE = "Procedure";
+function stripModifier5(key) {
+  const idx = key.indexOf(":");
+  return idx === -1 ? key : key.slice(0, idx);
+}
+function isResultParameter5(key) {
+  return key.startsWith("_");
+}
+function sendInvalidSearch4005(res, diagnostics) {
+  return res.status(400).json({
+    resourceType: "OperationOutcome",
+    issue: [{ severity: "error", code: "invalid", diagnostics }]
   });
 }
+function extractSearchParamKeys5(query) {
+  const out = [];
+  for (const rawKey of Object.keys(query)) {
+    if (isResultParameter5(rawKey)) {
+      continue;
+    }
+    out.push({ rawKey, code: stripModifier5(rawKey) });
+  }
+  return out;
+}
+function buildUnknownParamDiagnostics5(unknownCodes) {
+  const validCodes = getRegisteredSearchParameters(PROCEDURE_RESOURCE_TYPE).map((p) => p.code).sort().join(", ");
+  const codes = unknownCodes.join(", ");
+  const isPlural = unknownCodes.length !== 1;
+  return [
+    `Unknown search ${isPlural ? "parameters" : "parameter"} for Procedure: ${codes}.`,
+    `Valid codes: ${validCodes}.`
+  ].join(" ");
+}
+function findMalformedReference5(query, searchParamKeys) {
+  const referenceCodes = new Set(
+    getRegisteredSearchParameters(PROCEDURE_RESOURCE_TYPE).filter((p) => p.type === "reference").map((p) => p.code)
+  );
+  for (const { rawKey, code } of searchParamKeys) {
+    if (!referenceCodes.has(code)) {
+      continue;
+    }
+    const raw = query[rawKey];
+    const values = typeof raw === "string" ? raw.split(",") : Array.isArray(raw) ? raw.flatMap((v) => v.split(",")) : [];
+    for (const v of values) {
+      const trimmed = v.trim();
+      if (trimmed.length === 0) {
+        continue;
+      }
+      if (parseTypedReference(trimmed) === void 0) {
+        return { rawKey, value: trimmed };
+      }
+    }
+  }
+  return void 0;
+}
+async function listProceduresRoute(req, res) {
+  const searchParamKeys = extractSearchParamKeys5(
+    req.query
+  );
+  if (searchParamKeys.length === 0) {
+    return handleListRoute({
+      req,
+      res,
+      basePath: BASE_PATH.PROCEDURE,
+      listOperation: listProceduresOperation,
+      errorLogContext: "GET /Procedure list error:"
+    });
+  }
+  const registered = getRegisteredSearchParameters(PROCEDURE_RESOURCE_TYPE);
+  const validCodes = new Set(registered.map((p) => p.code));
+  const unknownCodes = searchParamKeys.map((k) => k.code).filter((code) => !validCodes.has(code));
+  if (unknownCodes.length > 0) {
+    return sendInvalidSearch4005(
+      res,
+      buildUnknownParamDiagnostics5([...new Set(unknownCodes)])
+    );
+  }
+  const malformedRef = findMalformedReference5(
+    req.query,
+    searchParamKeys
+  );
+  if (malformedRef !== void 0) {
+    return sendInvalidSearch4005(
+      res,
+      `?${malformedRef.rawKey} must be a typed reference like "Practitioner/<id>"; got "${malformedRef.value}".`
+    );
+  }
+  const ctx = req.openhiContext;
+  try {
+    const result = await genericSearchOperation({
+      resourceType: PROCEDURE_RESOURCE_TYPE,
+      tenantId: ctx.tenantId,
+      workspaceId: ctx.workspaceId,
+      query: req.query,
+      resolver: defaultSearchParameterResolver
+    });
+    const bundle = buildSearchsetBundle(BASE_PATH.PROCEDURE, result.entries);
+    return res.json(bundle);
+  } catch (err) {
+    return sendOperationOutcome500(res, err, "GET /Procedure search error:");
+  }
+}
 
 // src/data/operations/data/procedure/procedure-update-operation.ts
 async function updateProcedureOperation(params) {
@@ -29601,7 +29622,7 @@ async function listSchedulesOperation(params) {
 }
 
 // src/data/operations/data/schedule/schedule-search-by-actor-operation.ts
-var DEFAULT_LIMIT5 = 100;
+var DEFAULT_LIMIT2 = 100;
 function buildSearchSchedulesByActorSql() {
   return [
     "SELECT resource_id AS id, resource",
@@ -29619,7 +29640,7 @@ async function searchSchedulesByActorOperation(params) {
   const { context, actorReference } = params;
   const { tenantId, workspaceId } = context;
   const runner = params.runner ?? getDefaultPostgresQueryRunner();
-  const limit = params.limit ?? DEFAULT_LIMIT5;
+  const limit = params.limit ?? DEFAULT_LIMIT2;
   const { containmentRelative, containmentUrn } = buildReferenceContainmentPayload({
     shape: { kind: "array-of-references", field: "actor" },
     reference: actorReference,
@@ -29645,7 +29666,7 @@ async function searchSchedulesByActorOperation(params) {
 }
 
 // src/data/rest-api/routes/data/schedule/schedule-list-route.ts
-function singleStringQueryParam2(req, name) {
+function singleStringQueryParam(req, name) {
   const v = req.query[name];
   if (typeof v !== "string") {
     return void 0;
@@ -29653,17 +29674,17 @@ function singleStringQueryParam2(req, name) {
   const trimmed = v.trim();
   return trimmed === "" ? void 0 : trimmed;
 }
-function sendInvalidSearch4004(res, diagnostics) {
+function sendInvalidSearch4006(res, diagnostics) {
   return res.status(400).json({
     resourceType: "OperationOutcome",
     issue: [{ severity: "error", code: "invalid", diagnostics }]
   });
 }
 async function listSchedulesRoute(req, res) {
-  const actorRef = singleStringQueryParam2(req, "actor");
+  const actorRef = singleStringQueryParam(req, "actor");
   if (actorRef !== void 0) {
     if (parseTypedReference(actorRef) === void 0) {
-      return sendInvalidSearch4004(
+      return sendInvalidSearch4006(
         res,
         `?actor must be a typed reference like "Practitioner/<id>"; got "${actorRef}".`
       );
@@ -33365,7 +33386,7 @@ async function listTasksOperation(params) {
 }
 
 // src/data/operations/data/task/task-search-by-owner-operation.ts
-var DEFAULT_LIMIT6 = 100;
+var DEFAULT_LIMIT3 = 100;
 function buildSearchTasksByOwnerSql() {
   return [
     "SELECT resource_id AS id, resource",
@@ -33383,7 +33404,7 @@ async function searchTasksByOwnerOperation(params) {
   const { context, ownerReference } = params;
   const { tenantId, workspaceId } = context;
   const runner = params.runner ?? getDefaultPostgresQueryRunner();
-  const limit = params.limit ?? DEFAULT_LIMIT6;
+  const limit = params.limit ?? DEFAULT_LIMIT3;
   const { containmentRelative, containmentUrn } = buildReferenceContainmentPayload({
     shape: { kind: "scalar", field: "owner" },
     reference: ownerReference,
@@ -33409,7 +33430,7 @@ async function searchTasksByOwnerOperation(params) {
 }
 
 // src/data/operations/data/task/task-search-by-requester-operation.ts
-var DEFAULT_LIMIT7 = 100;
+var DEFAULT_LIMIT4 = 100;
 function buildSearchTasksByRequesterSql() {
   return [
     "SELECT resource_id AS id, resource",
@@ -33427,7 +33448,7 @@ async function searchTasksByRequesterOperation(params) {
   const { context, requesterReference } = params;
   const { tenantId, workspaceId } = context;
   const runner = params.runner ?? getDefaultPostgresQueryRunner();
-  const limit = params.limit ?? DEFAULT_LIMIT7;
+  const limit = params.limit ?? DEFAULT_LIMIT4;
   const { containmentRelative, containmentUrn } = buildReferenceContainmentPayload({
     shape: { kind: "scalar", field: "requester" },
     reference: requesterReference,
@@ -33453,7 +33474,7 @@ async function searchTasksByRequesterOperation(params) {
 }
 
 // src/data/rest-api/routes/data/task/task-list-route.ts
-function singleStringQueryParam3(req, name) {
+function singleStringQueryParam2(req, name) {
   const v = req.query[name];
   if (typeof v !== "string") {
     return void 0;
@@ -33461,24 +33482,24 @@ function singleStringQueryParam3(req, name) {
   const trimmed = v.trim();
   return trimmed === "" ? void 0 : trimmed;
 }
-function sendInvalidSearch4005(res, diagnostics) {
+function sendInvalidSearch4007(res, diagnostics) {
   return res.status(400).json({
     resourceType: "OperationOutcome",
     issue: [{ severity: "error", code: "invalid", diagnostics }]
   });
 }
 async function listTasksRoute(req, res) {
-  const ownerRef = singleStringQueryParam3(req, "owner");
-  const requesterRef = singleStringQueryParam3(req, "requester");
+  const ownerRef = singleStringQueryParam2(req, "owner");
+  const requesterRef = singleStringQueryParam2(req, "requester");
   if (ownerRef !== void 0 && requesterRef !== void 0) {
-    return sendInvalidSearch4005(
+    return sendInvalidSearch4007(
       res,
       "?owner= and ?requester= cannot be combined on the same request."
     );
   }
   if (ownerRef !== void 0) {
     if (parseTypedReference(ownerRef) === void 0) {
-      return sendInvalidSearch4005(
+      return sendInvalidSearch4007(
         res,
         `?owner must be a typed reference like "Practitioner/<id>"; got "${ownerRef}".`
       );
@@ -33501,7 +33522,7 @@ async function listTasksRoute(req, res) {
   }
   if (requesterRef !== void 0) {
     if (parseTypedReference(requesterRef) === void 0) {
-      return sendInvalidSearch4005(
+      return sendInvalidSearch4007(
         res,
         `?requester must be a typed reference like "Practitioner/<id>"; got "${requesterRef}".`
       );