@openhi/constructs 0.0.139 → 0.0.141

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

@@ -5405,6 +5405,89 @@ async function listAppointmentsOperation(params) {
   );
 }
 
+// src/data/search/engine/reference-predicate.ts
+function buildOpenHiResourceUrn(opts) {
+  return `urn:ohi:${opts.tenantId}:${opts.workspaceId}:${opts.resourceType}:${opts.resourceId}`;
+}
+var REFERENCE_CONTAINMENT_SQL_FRAGMENT = "(resource @> :containmentRelative::jsonb OR resource @> :containmentUrn::jsonb)";
+function parseTypedReference(s) {
+  const match = /^([A-Za-z][A-Za-z0-9_]*)\/([^\s/]+)$/.exec(s);
+  if (!match) {
+    return void 0;
+  }
+  return { resourceType: match[1], resourceId: match[2] };
+}
+function wrapReferenceInShape(shape, reference) {
+  switch (shape.kind) {
+    case "scalar":
+      return { [shape.field]: { reference } };
+    case "array-of-references":
+      return { [shape.field]: [{ reference }] };
+    case "array-of-objects":
+      return { [shape.field]: [{ [shape.subfield]: { reference } }] };
+  }
+}
+function buildReferenceContainmentPayload(params) {
+  const parsed = parseTypedReference(params.reference);
+  if (!parsed) {
+    throw new Error(
+      `Reference "${params.reference}" is not a valid typed reference (<ResourceType>/<id>).`
+    );
+  }
+  const urn = buildOpenHiResourceUrn({
+    tenantId: params.tenantId,
+    workspaceId: params.workspaceId,
+    resourceType: parsed.resourceType,
+    resourceId: parsed.resourceId
+  });
+  return {
+    containmentRelative: JSON.stringify(
+      wrapReferenceInShape(params.shape, params.reference)
+    ),
+    containmentUrn: JSON.stringify(wrapReferenceInShape(params.shape, urn))
+  };
+}
+function jsonbPathToReferenceShape(jsonbPath) {
+  const scalar = /^\$\.([A-Za-z_][A-Za-z0-9_]*)$/.exec(jsonbPath);
+  if (scalar) {
+    return { kind: "scalar", field: scalar[1] };
+  }
+  const arrayOfRefs = /^\$\.([A-Za-z_][A-Za-z0-9_]*)\[\*\]$/.exec(jsonbPath);
+  if (arrayOfRefs) {
+    return { kind: "array-of-references", field: arrayOfRefs[1] };
+  }
+  const arrayOfObjs = /^\$\.([A-Za-z_][A-Za-z0-9_]*)\[\*\]\.([A-Za-z_][A-Za-z0-9_]*)$/.exec(
+    jsonbPath
+  );
+  if (arrayOfObjs) {
+    return {
+      kind: "array-of-objects",
+      field: arrayOfObjs[1],
+      subfield: arrayOfObjs[2]
+    };
+  }
+  throw new Error(
+    `Reference predicate cannot translate JSONPath "${jsonbPath}". Supported shapes: "$.field", "$.field[*]", "$.field[*].subfield".`
+  );
+}
+function emitReferencePredicate(opts) {
+  const shape = jsonbPathToReferenceShape(opts.jsonbPath);
+  const { containmentRelative, containmentUrn } = buildReferenceContainmentPayload({
+    shape,
+    reference: opts.rawValue,
+    tenantId: opts.context.tenantId,
+    workspaceId: opts.context.workspaceId
+  });
+  const relName = `${opts.paramName}R`;
+  const urnName = `${opts.paramName}U`;
+  const sql = `(resource @> :${relName}::jsonb OR resource @> :${urnName}::jsonb)`;
+  const params = [
+    { name: relName, value: containmentRelative },
+    { name: urnName, value: containmentUrn }
+  ];
+  return { sql, params };
+}
+
 // src/data/postgres/data-api-postgres-query-runner.ts
 import {
   ExecuteStatementCommand,
@@ -5554,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]}'`;
   }
-  return `resource->>'${match[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]}'`;
+  }
+  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;
@@ -5596,129 +5683,95 @@ function emitFieldMissingPredicate(opts) {
   const sql = opts.missing ? `${extract} IS NULL` : `${extract} IS NOT NULL`;
   return { sql, params: [] };
 }
-var DEFAULT_INTERVAL_PARAM_PREFIX = "intervalDateConstraint";
-function intervalConstraintParamName(prefix, index) {
-  return `${prefix}${index}`;
+
+// src/data/search/engine/string-predicate.ts
+var STRING_MODIFIERS = ["exact", "contains"];
+function isStringModifier(s) {
+  return STRING_MODIFIERS.includes(s);
 }
-function buildIntervalSingleSql(prefix, startExtract, endExtract, paramName) {
-  switch (prefix) {
-    case "eq":
-      return `(${startExtract} IS NOT NULL AND ${startExtract} = :${paramName})`;
-    case "gt":
-      return `(${endExtract} IS NULL OR ${endExtract} > :${paramName})`;
-    case "lt":
-      return `(${startExtract} IS NULL OR ${startExtract} < :${paramName})`;
-    case "ge":
-      return `(${endExtract} IS NULL OR ${endExtract} >= :${paramName})`;
-    case "le":
-      return `(${startExtract} IS NULL OR ${startExtract} <= :${paramName})`;
-    case "sa":
-      return `(${startExtract} IS NOT NULL AND ${startExtract} > :${paramName})`;
-    case "eb":
-      return `(${endExtract} IS NOT NULL AND ${endExtract} < :${paramName})`;
-  }
-}
-function buildIntervalDateSearchPredicateSql(constraints, opts) {
-  if (constraints.length === 0) {
-    return [];
-  }
-  const paramPrefix = opts.paramNamePrefix ?? DEFAULT_INTERVAL_PARAM_PREFIX;
-  const startExtract = flatJsonbExtract(opts.startPath);
-  const endExtract = flatJsonbExtract(opts.endPath);
-  const fragments = constraints.map(
-    (c, i) => buildIntervalSingleSql(
-      c.prefix,
-      startExtract,
-      endExtract,
-      intervalConstraintParamName(paramPrefix, i)
-    )
+function jsonbPathToStringShape(jsonbPath) {
+  const scalar = /^\$\.([A-Za-z_][A-Za-z0-9_]*)$/.exec(jsonbPath);
+  if (scalar) {
+    return { kind: "scalar", field: scalar[1] };
+  }
+  const arrayOfScalars = /^\$\.([A-Za-z_][A-Za-z0-9_]*)\[\*\]$/.exec(jsonbPath);
+  if (arrayOfScalars) {
+    return { kind: "array-of-scalars", field: arrayOfScalars[1] };
+  }
+  const arrayOfObjs = /^\$\.([A-Za-z_][A-Za-z0-9_]*)\[\*\]\.([A-Za-z_][A-Za-z0-9_]*)$/.exec(
+    jsonbPath
   );
-  fragments.push(`(${startExtract} IS NOT NULL OR ${endExtract} IS NOT NULL)`);
-  return fragments;
-}
-function buildIntervalDateSearchPredicateParams(constraints, opts) {
-  const paramPrefix = opts?.paramNamePrefix ?? DEFAULT_INTERVAL_PARAM_PREFIX;
-  return constraints.map((c, i) => ({
-    name: intervalConstraintParamName(paramPrefix, i),
-    value: c.value
-  }));
-}
-var APPOINTMENT_DATE_SEARCH_PREFIXES = [
-  "gt",
-  "lt",
-  "ge",
-  "le",
-  "sa",
-  "eb"
-];
-function isAppointmentDateSearchPrefix(s) {
-  return APPOINTMENT_DATE_SEARCH_PREFIXES.includes(
-    s
+  if (arrayOfObjs) {
+    return {
+      kind: "array-of-objects",
+      field: arrayOfObjs[1],
+      subfield: arrayOfObjs[2]
+    };
+  }
+  throw new Error(
+    `String predicate cannot translate JSONPath "${jsonbPath}". Supported shapes: "$.field", "$.field[*]", "$.field[*].subfield".`
   );
 }
-function buildAppointmentDateSearchPredicateSql(constraints) {
-  return buildIntervalDateSearchPredicateSql(constraints, {
-    startPath: "$.start",
-    endPath: "$.end",
-    paramNamePrefix: "apptDateConstraint"
-  });
-}
-function buildAppointmentDateSearchPredicateParams(constraints) {
-  return buildIntervalDateSearchPredicateParams(constraints, {
-    paramNamePrefix: "apptDateConstraint"
-  });
-}
-
-// src/data/search/engine/reference-predicate.ts
-function buildOpenHiResourceUrn(opts) {
-  return `urn:ohi:${opts.tenantId}:${opts.workspaceId}:${opts.resourceType}:${opts.resourceId}`;
+function escapeLikePattern(value) {
+  return value.replace(/\\/g, "\\\\").replace(/%/g, "\\%").replace(/_/g, "\\_");
 }
-var REFERENCE_CONTAINMENT_SQL_FRAGMENT = "(resource @> :containmentRelative::jsonb OR resource @> :containmentUrn::jsonb)";
-function parseTypedReference(s) {
-  const match = /^([A-Za-z][A-Za-z0-9_]*)\/([^\s/]+)$/.exec(s);
-  if (!match) {
-    return void 0;
+function buildLikePattern(value, modifier) {
+  const escaped = escapeLikePattern(value);
+  switch (modifier) {
+    case "exact":
+      return escaped;
+    case "contains":
+      return `%${escaped}%`;
+    case void 0:
+      return `${escaped}%`;
   }
-  return { resourceType: match[1], resourceId: match[2] };
 }
-function wrapReferenceInShape(shape, reference) {
+function buildIlikeExtractSql(shape, paramName) {
   switch (shape.kind) {
     case "scalar":
-      return { [shape.field]: { reference } };
-    case "array-of-references":
-      return { [shape.field]: [{ reference }] };
+      return `resource->>'${shape.field}' ILIKE :${paramName}`;
+    case "array-of-scalars":
+      return [
+        "EXISTS (SELECT 1 FROM",
+        `jsonb_array_elements_text(resource->'${shape.field}') AS s_elem(text_val)`,
+        `WHERE s_elem.text_val ILIKE :${paramName})`
+      ].join(" ");
     case "array-of-objects":
-      return { [shape.field]: [{ [shape.subfield]: { reference } }] };
+      return [
+        "EXISTS (SELECT 1 FROM",
+        `jsonb_array_elements(resource->'${shape.field}') AS s_obj(obj)`,
+        `WHERE s_obj.obj->>'${shape.subfield}' ILIKE :${paramName})`
+      ].join(" ");
   }
 }
-function buildReferenceContainmentPayload(params) {
-  const parsed = parseTypedReference(params.reference);
-  if (!parsed) {
+function emitStringPredicate(opts) {
+  const shape = jsonbPathToStringShape(opts.jsonbPath);
+  const modifier = opts.modifier === void 0 ? void 0 : checkModifier(opts.modifier);
+  const sql = buildIlikeExtractSql(shape, opts.paramName);
+  const pattern = buildLikePattern(opts.rawValue, modifier);
+  const params = [
+    { name: opts.paramName, value: pattern }
+  ];
+  return { sql, params };
+}
+function checkModifier(modifier) {
+  if (!isStringModifier(modifier)) {
     throw new Error(
-      `Reference "${params.reference}" is not a valid typed reference (<ResourceType>/<id>).`
+      `String predicate does not support modifier ":${modifier}". Supported: ${STRING_MODIFIERS.map((m) => `:${m}`).join(", ")}.`
     );
   }
-  const urn = buildOpenHiResourceUrn({
-    tenantId: params.tenantId,
-    workspaceId: params.workspaceId,
-    resourceType: parsed.resourceType,
-    resourceId: parsed.resourceId
-  });
-  return {
-    containmentRelative: JSON.stringify(
-      wrapReferenceInShape(params.shape, params.reference)
-    ),
-    containmentUrn: JSON.stringify(wrapReferenceInShape(params.shape, urn))
-  };
+  return modifier;
 }
-function jsonbPathToReferenceShape(jsonbPath) {
+
+// src/data/search/engine/token-predicate.ts
+function jsonbPathToTokenShape(jsonbPath) {
   const scalar = /^\$\.([A-Za-z_][A-Za-z0-9_]*)$/.exec(jsonbPath);
   if (scalar) {
     return { kind: "scalar", field: scalar[1] };
   }
-  const arrayOfRefs = /^\$\.([A-Za-z_][A-Za-z0-9_]*)\[\*\]$/.exec(jsonbPath);
-  if (arrayOfRefs) {
-    return { kind: "array-of-references", field: arrayOfRefs[1] };
+  const arrayOfScalars = /^\$\.([A-Za-z_][A-Za-z0-9_]*)\[\*\]$/.exec(jsonbPath);
+  if (arrayOfScalars) {
+    return { kind: "array-of-scalars", field: arrayOfScalars[1] };
   }
   const arrayOfObjs = /^\$\.([A-Za-z_][A-Za-z0-9_]*)\[\*\]\.([A-Za-z_][A-Za-z0-9_]*)$/.exec(
     jsonbPath
@@ -5731,240 +5784,408 @@ function jsonbPathToReferenceShape(jsonbPath) {
     };
   }
   throw new Error(
-    `Reference predicate cannot translate JSONPath "${jsonbPath}". Supported shapes: "$.field", "$.field[*]", "$.field[*].subfield".`
+    `Token predicate cannot translate JSONPath "${jsonbPath}". Supported shapes: "$.field", "$.field[*]", "$.field[*].subfield".`
   );
 }
-function emitReferencePredicate(opts) {
-  const shape = jsonbPathToReferenceShape(opts.jsonbPath);
-  const { containmentRelative, containmentUrn } = buildReferenceContainmentPayload({
-    shape,
-    reference: opts.rawValue,
-    tenantId: opts.context.tenantId,
-    workspaceId: opts.context.workspaceId
-  });
-  const relName = `${opts.paramName}R`;
-  const urnName = `${opts.paramName}U`;
-  const sql = `(resource @> :${relName}::jsonb OR resource @> :${urnName}::jsonb)`;
+function parseTokenValue(raw) {
+  const idx = raw.indexOf("|");
+  if (idx === -1) {
+    return { code: raw };
+  }
+  const system = raw.slice(0, idx);
+  const code = raw.slice(idx + 1);
+  return system.length > 0 ? { system, code } : { code };
+}
+function wrapTokenInShape(shape, value) {
+  switch (shape.kind) {
+    case "scalar":
+      return { [shape.field]: value };
+    case "array-of-scalars":
+      return { [shape.field]: [value] };
+    case "array-of-objects":
+      return { [shape.field]: [{ [shape.subfield]: value }] };
+  }
+}
+function emitTokenPredicate(opts) {
+  const shape = jsonbPathToTokenShape(opts.jsonbPath);
+  const { code } = parseTokenValue(opts.rawValue);
+  const payload = wrapTokenInShape(shape, code);
+  const sql = `resource @> :${opts.paramName}::jsonb`;
   const params = [
-    { name: relName, value: containmentRelative },
-    { name: urnName, value: containmentUrn }
+    { name: opts.paramName, value: JSON.stringify(payload) }
   ];
   return { sql, params };
 }
 
-// src/data/operations/data/appointment/appointment-search-by-actor-operation.ts
-var DEFAULT_LIMIT = 100;
-function buildSearchAppointmentsByActorSql(opts) {
-  const datePredicates = buildAppointmentDateSearchPredicateSql(
-    opts?.dateConstraints ?? []
-  );
-  const lines = [
-    "SELECT resource_id AS id, resource",
-    "FROM resources",
-    "WHERE tenant_id = :tenantId",
-    "  AND workspace_id = :workspaceId",
-    "  AND resource_type = 'Appointment'",
-    "  AND deleted_at IS NULL",
-    `  AND ${REFERENCE_CONTAINMENT_SQL_FRAGMENT}`
-  ];
-  for (const fragment of datePredicates) {
-    lines.push(`  AND ${fragment}`);
+// src/data/search/engine/combinator.ts
+function parseQueryKey(key) {
+  const idx = key.indexOf(":");
+  if (idx === -1) {
+    return { code: key, modifier: void 0 };
   }
-  lines.push("ORDER BY last_updated DESC");
-  lines.push("LIMIT :limit;");
-  return lines.join("\n");
+  return { code: key.slice(0, idx), modifier: key.slice(idx + 1) };
 }
-async function searchAppointmentsByActorOperation(params) {
-  const { context, actorReference } = params;
-  const dateConstraints = params.dateConstraints ?? [];
-  const { tenantId, workspaceId } = context;
-  const runner = params.runner ?? getDefaultPostgresQueryRunner();
-  const limit = params.limit ?? DEFAULT_LIMIT;
-  const { containmentRelative, containmentUrn } = buildReferenceContainmentPayload({
-    shape: {
-      kind: "array-of-objects",
-      field: "participant",
-      subfield: "actor"
-    },
-    reference: actorReference,
-    tenantId,
-    workspaceId
-  });
-  const sql = buildSearchAppointmentsByActorSql({ dateConstraints });
-  const queryParams = [
-    { name: "tenantId", value: tenantId },
-    { name: "workspaceId", value: workspaceId },
-    { name: "containmentRelative", value: containmentRelative },
-    { name: "containmentUrn", value: containmentUrn },
-    { name: "limit", value: limit },
-    ...buildAppointmentDateSearchPredicateParams(dateConstraints)
-  ];
-  const rows = await runner.query(sql, queryParams);
-  const entries = rows.map((row) => ({
-    id: row.id,
-    resource: {
-      ...row.resource,
-      id: row.id
+function flattenQueryValues(raw) {
+  const list = Array.isArray(raw) ? raw : [raw];
+  const out = [];
+  for (const v of list) {
+    for (const piece of v.split(",")) {
+      out.push(piece);
     }
-  }));
-  return { entries, total: entries.length };
+  }
+  return out;
 }
-
-// src/data/operations/data/appointment/appointment-search-by-date-operation.ts
-var DEFAULT_LIMIT2 = 100;
-function buildSearchAppointmentsByDateSql(opts) {
-  const datePredicates = buildAppointmentDateSearchPredicateSql(
-    opts.dateConstraints
+function parseQueryEntries(query) {
+  const entries = [];
+  for (const [rawKey, rawValue] of Object.entries(query)) {
+    if (rawValue === void 0) continue;
+    const { code, modifier } = parseQueryKey(rawKey);
+    entries.push({
+      code,
+      modifier,
+      values: flattenQueryValues(rawValue)
+    });
+  }
+  return entries;
+}
+function findParam(params, code) {
+  return params.find((p) => p.code === code);
+}
+function checkModifierAllowed(modifier, param) {
+  const universal = modifier === "missing" || modifier === "not";
+  const stringNative = param.type === "string" && (modifier === "exact" || modifier === "contains");
+  if (universal || stringNative) {
+    if (param.modifiers && !param.modifiers.includes(modifier)) {
+      throw new Error(
+        `Modifier ":${modifier}" is not in the allow-list for param "${param.code}".`
+      );
+    }
+    return;
+  }
+  throw new Error(
+    `Modifier ":${modifier}" is not recognized for param "${param.code}" (type "${param.type}").`
   );
-  const lines = [
-    "SELECT resource_id AS id, resource",
-    "FROM resources",
-    "WHERE tenant_id = :tenantId",
-    "  AND workspace_id = :workspaceId",
-    "  AND resource_type = 'Appointment'",
-    "  AND deleted_at IS NULL"
-  ];
-  for (const fragment of datePredicates) {
-    lines.push(`  AND ${fragment}`);
+}
+function emitOne(opts) {
+  const { param, modifier, rawValue, paramName, context } = opts;
+  if (modifier === "missing") {
+    const missing = parseMissingValue(rawValue);
+    return emitFieldMissingPredicate({
+      jsonbPath: param.jsonbPath,
+      missing
+    });
   }
-  lines.push("ORDER BY last_updated DESC");
-  lines.push("LIMIT :limit;");
-  return lines.join("\n");
+  const negate = modifier === "not";
+  const effectiveModifier = negate ? void 0 : modifier;
+  const inner = emitForType({
+    paramType: param.type,
+    jsonbPath: param.jsonbPath,
+    rawValue,
+    paramName,
+    modifier: effectiveModifier,
+    context
+  });
+  if (!negate) {
+    return inner;
+  }
+  return { sql: `NOT (${inner.sql})`, params: inner.params };
 }
-async function searchAppointmentsByDateOperation(params) {
-  const { context, dateConstraints } = params;
-  if (dateConstraints.length === 0) {
-    throw new Error(
-      "searchAppointmentsByDateOperation requires at least one dateConstraint"
-    );
+function parseMissingValue(raw) {
+  if (raw === "true") return true;
+  if (raw === "false") return false;
+  throw new Error(
+    `:missing requires a value of "true" or "false"; received "${raw}".`
+  );
+}
+function emitForType(opts) {
+  switch (opts.paramType) {
+    case "token":
+      return emitTokenPredicate({
+        jsonbPath: opts.jsonbPath,
+        rawValue: opts.rawValue,
+        paramName: opts.paramName,
+        context: opts.context
+      });
+    case "date":
+      return emitDatePredicate({
+        jsonbPath: opts.jsonbPath,
+        rawValue: opts.rawValue,
+        paramName: opts.paramName,
+        context: opts.context
+      });
+    case "reference":
+      return emitReferencePredicate({
+        jsonbPath: opts.jsonbPath,
+        rawValue: opts.rawValue,
+        paramName: opts.paramName,
+        context: opts.context
+      });
+    case "string":
+      return emitStringPredicate({
+        jsonbPath: opts.jsonbPath,
+        rawValue: opts.rawValue,
+        paramName: opts.paramName,
+        modifier: opts.modifier,
+        context: opts.context
+      });
   }
-  const { tenantId, workspaceId } = context;
-  const runner = params.runner ?? getDefaultPostgresQueryRunner();
-  const limit = params.limit ?? DEFAULT_LIMIT2;
-  const sql = buildSearchAppointmentsByDateSql({ dateConstraints });
-  const queryParams = [
-    { name: "tenantId", value: tenantId },
-    { name: "workspaceId", value: workspaceId },
-    { name: "limit", value: limit },
-    ...buildAppointmentDateSearchPredicateParams(dateConstraints)
-  ];
-  const rows = await runner.query(sql, queryParams);
-  const entries = rows.map((row) => ({
-    id: row.id,
-    resource: {
-      ...row.resource,
-      id: row.id
+}
+function combineSearchPredicates(opts) {
+  const entries = parseQueryEntries(opts.query);
+  const groupSqls = [];
+  const allParams = [];
+  let paramIdx = 0;
+  for (const entry of entries) {
+    const registered = findParam(opts.registeredParams, entry.code);
+    if (!registered) {
+      continue;
     }
-  }));
-  return { entries, total: entries.length };
+    if (entry.modifier !== void 0) {
+      checkModifierAllowed(entry.modifier, registered);
+    }
+    if (entry.values.length === 0) {
+      continue;
+    }
+    const fragmentSqls = [];
+    let valueIdx = 0;
+    for (const rawValue of entry.values) {
+      const paramName = `p${paramIdx}v${valueIdx}`;
+      const frag = emitOne({
+        param: registered,
+        modifier: entry.modifier,
+        rawValue,
+        paramName,
+        context: opts.context
+      });
+      fragmentSqls.push(frag.sql);
+      for (const p of frag.params) {
+        allParams.push(p);
+      }
+      valueIdx++;
+    }
+    paramIdx++;
+    if (fragmentSqls.length === 1) {
+      groupSqls.push(fragmentSqls[0]);
+    } else {
+      groupSqls.push(`(${fragmentSqls.join(" OR ")})`);
+    }
+  }
+  if (groupSqls.length === 0) {
+    return { sql: "", params: [] };
+  }
+  return { sql: groupSqls.join(" AND "), params: allParams };
 }
 
-// src/data/operations/data/appointment/appointment-search-by-patient-operation.ts
-var DEFAULT_LIMIT3 = 100;
-function buildSearchAppointmentsByPatientSql(opts) {
-  const datePredicates = buildAppointmentDateSearchPredicateSql(
-    opts?.dateConstraints ?? []
-  );
+// src/data/search/operations/generic-search-operation.ts
+var DEFAULT_LIMIT = 100;
+function buildGenericSearchSql(opts) {
   const lines = [
     "SELECT resource_id AS id, resource",
     "FROM resources",
     "WHERE tenant_id = :tenantId",
     "  AND workspace_id = :workspaceId",
-    "  AND resource_type = 'Appointment'",
-    "  AND deleted_at IS NULL",
-    "  AND (resource @> :containmentRelative::jsonb",
-    "    OR resource @> :containmentUrn::jsonb)"
+    "  AND resource_type = :resourceType",
+    "  AND deleted_at IS NULL"
   ];
-  for (const fragment of datePredicates) {
-    lines.push(`  AND ${fragment}`);
+  if (opts.combinedSql.length > 0) {
+    lines.push(`  AND (${opts.combinedSql})`);
   }
   lines.push("ORDER BY last_updated DESC");
   lines.push("LIMIT :limit;");
   return lines.join("\n");
 }
-async function searchAppointmentsByPatientOperation(params) {
-  const { context, patientId } = params;
-  const dateConstraints = params.dateConstraints ?? [];
-  const { tenantId, workspaceId } = context;
+async function genericSearchOperation(params) {
+  const { resourceType, tenantId, workspaceId, query, resolver } = params;
   const runner = params.runner ?? getDefaultPostgresQueryRunner();
-  const limit = params.limit ?? DEFAULT_LIMIT3;
-  const containmentRelative = JSON.stringify({
-    participant: [{ actor: { reference: `Patient/${patientId}` } }]
-  });
-  const containmentUrn = JSON.stringify({
-    participant: [
-      {
-        actor: {
-          reference: buildOpenHiResourceUrn({
-            tenantId,
-            workspaceId,
-            resourceType: "Patient",
-            resourceId: patientId
-          })
-        }
-      }
-    ]
+  const limit = params.limit ?? DEFAULT_LIMIT;
+  const registeredParams = resolver(resourceType, tenantId);
+  const context = { tenantId, workspaceId, resourceType };
+  const combined = combineSearchPredicates({
+    query,
+    registeredParams,
+    context
   });
-  const sql = buildSearchAppointmentsByPatientSql({ dateConstraints });
+  const sql = buildGenericSearchSql({ combinedSql: combined.sql });
   const queryParams = [
     { name: "tenantId", value: tenantId },
     { name: "workspaceId", value: workspaceId },
-    { name: "containmentRelative", value: containmentRelative },
-    { name: "containmentUrn", value: containmentUrn },
+    { name: "resourceType", value: resourceType },
     { name: "limit", value: limit },
-    ...buildAppointmentDateSearchPredicateParams(dateConstraints)
+    ...combined.params
   ];
   const rows = await runner.query(sql, queryParams);
   const entries = rows.map((row) => ({
     id: row.id,
-    resource: {
-      ...row.resource,
-      id: row.id
-    }
+    resource: { ...row.resource, id: row.id }
   }));
   return { entries, total: entries.length };
 }
 
-// src/data/rest-api/routes/data/appointment/appointment-list-route.ts
-function singleStringQueryParam(req, name) {
-  const v = req.query[name];
-  if (typeof v !== "string") {
-    return void 0;
-  }
-  const trimmed = v.trim();
-  return trimmed === "" ? void 0 : trimmed;
-}
-function isError(v) {
-  return v.error !== void 0;
-}
-function parseAppointmentDateConstraints(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 (!isAppointmentDateSearchPrefix(prefix)) {
-      return {
-        error: `Unsupported ?date= prefix in "${trimmed}". Supported prefixes: ${APPOINTMENT_DATE_SEARCH_PREFIXES.join(", ")}.`
-      };
-    }
-    if (datetime === "" || Number.isNaN(Date.parse(datetime))) {
-      return { error: `Invalid datetime in ?date=${trimmed}.` };
-    }
-    out.push({ prefix, value: datetime });
+// src/data/search/registry/appointment-search-parameters.ts
+var APPOINTMENT_SEARCH_PARAMETERS = [
+  { code: "status", type: "token", jsonbPath: "$.status" },
+  { code: "date", type: "date", jsonbPath: "$.start" },
+  {
+    code: "patient",
+    type: "reference",
+    jsonbPath: "$.participant[*].actor"
+  },
+  {
+    code: "actor",
+    type: "reference",
+    jsonbPath: "$.participant[*].actor"
+  },
+  {
+    code: "practitioner",
+    type: "reference",
+    jsonbPath: "$.participant[*].actor"
+  },
+  { code: "service-type", type: "token", jsonbPath: "$.serviceType[*]" },
+  {
+    code: "service-category",
+    type: "token",
+    jsonbPath: "$.serviceCategory[*]"
+  },
+  { code: "specialty", type: "token", jsonbPath: "$.specialty[*]" },
+  {
+    code: "appointment-type",
+    type: "token",
+    jsonbPath: "$.appointmentType"
+  },
+  { 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[*]"
   }
-  return out;
+];
+
+// 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" },
+  { code: "identifier", type: "token", jsonbPath: "$.identifier[*].value" },
+  { code: "birthdate", type: "date", jsonbPath: "$.birthDate" },
+  {
+    code: "name",
+    type: "string",
+    jsonbPath: "$.name[*].text",
+    modifiers: ["exact", "contains", "missing", "not"]
+  },
+  {
+    code: "family",
+    type: "string",
+    jsonbPath: "$.name[*].family",
+    modifiers: ["exact", "contains", "missing", "not"]
+  },
+  {
+    code: "given",
+    type: "string",
+    jsonbPath: "$.name[*].given",
+    modifiers: ["exact", "contains", "missing", "not"]
+  },
+  { code: "active", type: "token", jsonbPath: "$.active" },
+  { code: "deceased", type: "token", jsonbPath: "$.deceasedBoolean" },
+  {
+    code: "general-practitioner",
+    type: "reference",
+    jsonbPath: "$.generalPractitioner[*]"
+  },
+  {
+    code: "organization",
+    type: "reference",
+    jsonbPath: "$.managingOrganization"
+  }
+];
+
+// 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,
+  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) {
+  return STATIC_SEARCH_PARAMETER_MAP[resourceType] ?? [];
+}
+
+// src/data/rest-api/routes/data/appointment/appointment-list-route.ts
+var APPOINTMENT_RESOURCE_TYPE = "Appointment";
+function stripModifier(key) {
+  const idx = key.indexOf(":");
+  return idx === -1 ? key : key.slice(0, idx);
+}
+function isResultParameter(key) {
+  return key.startsWith("_");
 }
 function sendInvalidSearch400(res, diagnostics) {
   return res.status(400).json({
@@ -5972,95 +6193,93 @@ function sendInvalidSearch400(res, diagnostics) {
     issue: [{ severity: "error", code: "invalid", diagnostics }]
   });
 }
+function extractSearchParamKeys(query) {
+  const out = [];
+  for (const rawKey of Object.keys(query)) {
+    if (isResultParameter(rawKey)) {
+      continue;
+    }
+    out.push({ rawKey, code: stripModifier(rawKey) });
+  }
+  return out;
+}
+function buildUnknownParamDiagnostics(unknownCodes) {
+  const validCodes = getRegisteredSearchParameters(APPOINTMENT_RESOURCE_TYPE).map((p) => p.code).sort().join(", ");
+  const codes = unknownCodes.join(", ");
+  const isPlural = unknownCodes.length !== 1;
+  return [
+    `Unknown search ${isPlural ? "parameters" : "parameter"} for Appointment: ${codes}.`,
+    `Valid codes: ${validCodes}.`
+  ].join(" ");
+}
+function findMalformedReference(query, searchParamKeys) {
+  const referenceCodes = new Set(
+    getRegisteredSearchParameters(APPOINTMENT_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 listAppointmentsRoute(req, res) {
-  const patientId = singleStringQueryParam(req, "patient");
-  const actorRef = singleStringQueryParam(req, "actor");
-  const parsed = parseAppointmentDateConstraints(req);
-  if (isError(parsed)) {
-    return sendInvalidSearch400(res, parsed.error);
+  const searchParamKeys = extractSearchParamKeys(
+    req.query
+  );
+  if (searchParamKeys.length === 0) {
+    return handleListRoute({
+      req,
+      res,
+      basePath: BASE_PATH.APPOINTMENT,
+      listOperation: listAppointmentsOperation,
+      errorLogContext: "GET /Appointment list error:"
+    });
   }
-  const dateConstraints = parsed;
-  if (patientId !== void 0 && actorRef !== void 0) {
+  const registered = getRegisteredSearchParameters(APPOINTMENT_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 sendInvalidSearch400(
       res,
-      "?patient= and ?actor= cannot be combined on the same request."
+      buildUnknownParamDiagnostics([...new Set(unknownCodes)])
     );
   }
-  if (actorRef !== void 0) {
-    if (parseTypedReference(actorRef) === void 0) {
-      return sendInvalidSearch400(
-        res,
-        `?actor must be a typed reference like "Practitioner/<id>"; got "${actorRef}".`
-      );
-    }
-    const ctx = req.openhiContext;
-    try {
-      const result = await searchAppointmentsByActorOperation({
-        context: ctx,
-        actorReference: actorRef,
-        dateConstraints
-      });
-      const bundle = buildSearchsetBundle(
-        BASE_PATH.APPOINTMENT,
-        result.entries
-      );
-      return res.json(bundle);
-    } catch (err) {
-      return sendOperationOutcome500(
-        res,
-        err,
-        "GET /Appointment?actor= search error:"
-      );
-    }
-  }
-  if (patientId !== void 0) {
-    const ctx = req.openhiContext;
-    try {
-      const result = await searchAppointmentsByPatientOperation({
-        context: ctx,
-        patientId,
-        dateConstraints
-      });
-      const bundle = buildSearchsetBundle(
-        BASE_PATH.APPOINTMENT,
-        result.entries
-      );
-      return res.json(bundle);
-    } catch (err) {
-      return sendOperationOutcome500(
-        res,
-        err,
-        "GET /Appointment?patient= search error:"
-      );
-    }
+  const malformedRef = findMalformedReference(
+    req.query,
+    searchParamKeys
+  );
+  if (malformedRef !== void 0) {
+    return sendInvalidSearch400(
+      res,
+      `?${malformedRef.rawKey} must be a typed reference like "Practitioner/<id>"; got "${malformedRef.value}".`
+    );
   }
-  if (dateConstraints.length > 0) {
-    const ctx = req.openhiContext;
-    try {
-      const result = await searchAppointmentsByDateOperation({
-        context: ctx,
-        dateConstraints
-      });
-      const bundle = buildSearchsetBundle(
-        BASE_PATH.APPOINTMENT,
-        result.entries
-      );
-      return res.json(bundle);
-    } catch (err) {
-      return sendOperationOutcome500(
-        res,
-        err,
-        "GET /Appointment?date= search error:"
-      );
-    }
+  const ctx = req.openhiContext;
+  try {
+    const result = await genericSearchOperation({
+      resourceType: APPOINTMENT_RESOURCE_TYPE,
+      tenantId: ctx.tenantId,
+      workspaceId: ctx.workspaceId,
+      query: req.query,
+      resolver: defaultSearchParameterResolver
+    });
+    const bundle = buildSearchsetBundle(BASE_PATH.APPOINTMENT, result.entries);
+    return res.json(bundle);
+  } catch (err) {
+    return sendOperationOutcome500(res, err, "GET /Appointment search error:");
   }
-  return handleListRoute({
-    req,
-    res,
-    basePath: BASE_PATH.APPOINTMENT,
-    listOperation: listAppointmentsOperation,
-    errorLogContext: "GET /Appointment list error:"
-  });
 }
 
 // src/data/operations/data/appointment/appointment-update-operation.ts
@@ -13568,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);
+// 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);
 }
-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 isResultParameter2(key) {
+  return key.startsWith("_");
 }
-function periodConstraintParamName(index) {
-  return `periodConstraint${index}`;
+function sendInvalidSearch4002(res, diagnostics) {
+  return res.status(400).json({
+    resourceType: "OperationOutcome",
+    issue: [{ severity: "error", code: "invalid", diagnostics }]
+  });
 }
-function buildPeriodSearchPredicateSql(constraints) {
-  if (constraints.length === 0) {
-    return [];
+function extractSearchParamKeys2(query) {
+  const out = [];
+  for (const rawKey of Object.keys(query)) {
+    if (isResultParameter2(rawKey)) {
+      continue;
+    }
+    out.push({ rawKey, code: stripModifier2(rawKey) });
   }
-  const fragments = constraints.map(
-    (c, i) => buildSinglePredicateSql(c.prefix, periodConstraintParamName(i))
-  );
-  fragments.push(HAS_ANY_BOUND_GUARD);
-  return fragments;
+  return out;
 }
-function buildPeriodSearchPredicateParams(constraints) {
-  return constraints.map((c, i) => ({
-    name: periodConstraintParamName(i),
-    value: c.value
-  }));
+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(" ");
 }
-
-// src/data/operations/data/encounter/encounter-search-by-date-operation.ts
-var DEFAULT_LIMIT4 = 100;
-function buildSearchEncountersByDateSql(opts) {
-  const periodPredicates = buildPeriodSearchPredicateSql(
-    opts.periodConstraints
+function findMalformedReference2(query, searchParamKeys) {
+  const referenceCodes = new Set(
+    getRegisteredSearchParameters(ENCOUNTER_RESOURCE_TYPE).filter((p) => p.type === "reference").map((p) => p.code)
   );
-  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_LIMIT4;
-  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/operations/data/encounter/encounter-search-by-participant-operation.ts
-var DEFAULT_LIMIT5 = 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");
-}
-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_LIMIT5;
-  const { containmentRelative, containmentUrn } = buildReferenceContainmentPayload({
-    shape: {
-      kind: "array-of-objects",
-      field: "participant",
-      subfield: "individual"
-    },
-    reference: participantReference,
-    tenantId,
-    workspaceId
-  });
-  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_LIMIT6 = 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_LIMIT6;
-  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
-    }
-  }));
-  return { entries, total: entries.length };
-}
-
-// src/data/rest-api/routes/data/encounter/encounter-list-route.ts
-function singleStringQueryParam2(req, name) {
-  const v = req.query[name];
-  if (typeof v !== "string") {
-    return void 0;
-  }
-  const trimmed = v.trim();
-  return trimmed === "" ? void 0 : trimmed;
-}
-function isError2(v) {
-  return v.error !== void 0;
-}
-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(", ")}.`
-      };
+  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 = singleStringQueryParam2(req, "patient");
-  const participantRef = singleStringQueryParam2(req, "participant");
-  const parsed = parseEncounterDateConstraints(req);
-  if (isError2(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
@@ -24594,44 +24568,137 @@ 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 }]
   });
 }
-
-// src/data/operations/data/observation/observation-update-operation.ts
-async function updateObservationOperation(params) {
-  const { context, id, body, tableName } = params;
-  const { tenantId, workspaceId, date, actorId, actorName } = context;
-  const service = getDynamoDataService(tableName);
-  return updateDataEntityById(
-    service.entities.observation,
-    tenantId,
-    workspaceId,
-    id,
-    "Observation",
-    context,
-    (existingResourceStr) => buildUpdatedResourceWithAudit(
-      body,
-      id,
-      date,
-      actorId,
-      actorName,
-      existingResourceStr,
-      "Observation"
-    )
-  );
+function extractSearchParamKeys3(query) {
+  const out = [];
+  for (const rawKey of Object.keys(query)) {
+    if (isResultParameter3(rawKey)) {
+      continue;
+    }
+    out.push({ rawKey, code: stripModifier3(rawKey) });
+  }
+  return out;
 }
-
-// src/data/rest-api/routes/data/observation/observation-update-route.ts
-async function updateObservationRoute(req, res) {
-  const bodyResult = requireJsonBodyAs(req, res);
-  if ("errorResponse" in bodyResult) return bodyResult.errorResponse;
+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) {
+  const { context, id, body, tableName } = params;
+  const { tenantId, workspaceId, date, actorId, actorName } = context;
+  const service = getDynamoDataService(tableName);
+  return updateDataEntityById(
+    service.entities.observation,
+    tenantId,
+    workspaceId,
+    id,
+    "Observation",
+    context,
+    (existingResourceStr) => buildUpdatedResourceWithAudit(
+      body,
+      id,
+      date,
+      actorId,
+      actorName,
+      existingResourceStr,
+      "Observation"
+    )
+  );
+}
+
+// src/data/rest-api/routes/data/observation/observation-update-route.ts
+async function updateObservationRoute(req, res) {
+  const bodyResult = requireJsonBodyAs(req, res);
+  if ("errorResponse" in bodyResult) return bodyResult.errorResponse;
   const id = String(req.params.id);
   const ctx = req.openhiContext;
   const body = bodyResult.body;
@@ -25499,492 +25566,109 @@ async function createPatientRoute(req, res) {
   try {
     const result = await createPatientOperation({
       context: ctx,
-      body: patient
-    });
-    return res.status(201).location(`${BASE_PATH.PATIENT}/${result.id}`).json(result.resource);
-  } catch (err) {
-    return sendOperationOutcome500(res, err, "POST Patient error:");
-  }
-}
-
-// src/data/operations/data/patient/patient-delete-operation.ts
-async function deletePatientOperation(params) {
-  const { context, id, tableName } = params;
-  const { tenantId, workspaceId } = context;
-  const service = getDynamoDataService(tableName);
-  await deleteDataEntityById(
-    service.entities.patient,
-    tenantId,
-    workspaceId,
-    id
-  );
-}
-
-// src/data/rest-api/routes/data/patient/patient-delete-route.ts
-async function deletePatientRoute(req, res) {
-  const id = String(req.params.id);
-  const ctx = req.openhiContext;
-  try {
-    await deletePatientOperation({ context: ctx, id });
-    return res.status(204).send();
-  } catch (err) {
-    return sendOperationOutcome500(res, err, "DELETE Patient error:");
-  }
-}
-
-// src/data/operations/data/patient/patient-get-by-id-operation.ts
-async function getPatientByIdOperation(params) {
-  const { context, id, tableName } = params;
-  const { tenantId, workspaceId } = context;
-  const service = getDynamoDataService(tableName);
-  return getDataEntityById(
-    service.entities.patient,
-    tenantId,
-    workspaceId,
-    id,
-    "Patient"
-  );
-}
-
-// src/data/rest-api/routes/data/patient/patient-get-by-id-route.ts
-async function getPatientByIdRoute(req, res) {
-  const id = String(req.params.id);
-  const ctx = req.openhiContext;
-  try {
-    const result = await getPatientByIdOperation({ context: ctx, id });
-    return res.json(result.resource);
-  } catch (err) {
-    const status = domainErrorToHttpStatus(err);
-    if (status === 404) {
-      const diagnostics = err instanceof NotFoundError ? err.message : `Patient ${id} not found`;
-      return sendOperationOutcome404(res, diagnostics);
-    }
-    return sendOperationOutcome500(res, err, "GET Patient error:");
-  }
-}
-
-// src/data/operations/data/patient/patient-list-operation.ts
-async function listPatientsOperation(params) {
-  const { context, tableName, mode } = params;
-  const { tenantId, workspaceId } = context;
-  const service = getDynamoDataService(tableName);
-  return listDataEntitiesByWorkspace(
-    service.entities.patient,
-    tenantId,
-    workspaceId,
-    mode
-  );
-}
-
-// src/data/search/engine/string-predicate.ts
-var STRING_MODIFIERS = ["exact", "contains"];
-function isStringModifier(s) {
-  return STRING_MODIFIERS.includes(s);
-}
-function jsonbPathToStringShape(jsonbPath) {
-  const scalar = /^\$\.([A-Za-z_][A-Za-z0-9_]*)$/.exec(jsonbPath);
-  if (scalar) {
-    return { kind: "scalar", field: scalar[1] };
-  }
-  const arrayOfScalars = /^\$\.([A-Za-z_][A-Za-z0-9_]*)\[\*\]$/.exec(jsonbPath);
-  if (arrayOfScalars) {
-    return { kind: "array-of-scalars", field: arrayOfScalars[1] };
-  }
-  const arrayOfObjs = /^\$\.([A-Za-z_][A-Za-z0-9_]*)\[\*\]\.([A-Za-z_][A-Za-z0-9_]*)$/.exec(
-    jsonbPath
-  );
-  if (arrayOfObjs) {
-    return {
-      kind: "array-of-objects",
-      field: arrayOfObjs[1],
-      subfield: arrayOfObjs[2]
-    };
-  }
-  throw new Error(
-    `String predicate cannot translate JSONPath "${jsonbPath}". Supported shapes: "$.field", "$.field[*]", "$.field[*].subfield".`
-  );
-}
-function escapeLikePattern(value) {
-  return value.replace(/\\/g, "\\\\").replace(/%/g, "\\%").replace(/_/g, "\\_");
-}
-function buildLikePattern(value, modifier) {
-  const escaped = escapeLikePattern(value);
-  switch (modifier) {
-    case "exact":
-      return escaped;
-    case "contains":
-      return `%${escaped}%`;
-    case void 0:
-      return `${escaped}%`;
-  }
-}
-function buildIlikeExtractSql(shape, paramName) {
-  switch (shape.kind) {
-    case "scalar":
-      return `resource->>'${shape.field}' ILIKE :${paramName}`;
-    case "array-of-scalars":
-      return [
-        "EXISTS (SELECT 1 FROM",
-        `jsonb_array_elements_text(resource->'${shape.field}') AS s_elem(text_val)`,
-        `WHERE s_elem.text_val ILIKE :${paramName})`
-      ].join(" ");
-    case "array-of-objects":
-      return [
-        "EXISTS (SELECT 1 FROM",
-        `jsonb_array_elements(resource->'${shape.field}') AS s_obj(obj)`,
-        `WHERE s_obj.obj->>'${shape.subfield}' ILIKE :${paramName})`
-      ].join(" ");
-  }
-}
-function emitStringPredicate(opts) {
-  const shape = jsonbPathToStringShape(opts.jsonbPath);
-  const modifier = opts.modifier === void 0 ? void 0 : checkModifier(opts.modifier);
-  const sql = buildIlikeExtractSql(shape, opts.paramName);
-  const pattern = buildLikePattern(opts.rawValue, modifier);
-  const params = [
-    { name: opts.paramName, value: pattern }
-  ];
-  return { sql, params };
-}
-function checkModifier(modifier) {
-  if (!isStringModifier(modifier)) {
-    throw new Error(
-      `String predicate does not support modifier ":${modifier}". Supported: ${STRING_MODIFIERS.map((m) => `:${m}`).join(", ")}.`
-    );
-  }
-  return modifier;
-}
-
-// src/data/search/engine/token-predicate.ts
-function jsonbPathToTokenShape(jsonbPath) {
-  const scalar = /^\$\.([A-Za-z_][A-Za-z0-9_]*)$/.exec(jsonbPath);
-  if (scalar) {
-    return { kind: "scalar", field: scalar[1] };
-  }
-  const arrayOfScalars = /^\$\.([A-Za-z_][A-Za-z0-9_]*)\[\*\]$/.exec(jsonbPath);
-  if (arrayOfScalars) {
-    return { kind: "array-of-scalars", field: arrayOfScalars[1] };
-  }
-  const arrayOfObjs = /^\$\.([A-Za-z_][A-Za-z0-9_]*)\[\*\]\.([A-Za-z_][A-Za-z0-9_]*)$/.exec(
-    jsonbPath
-  );
-  if (arrayOfObjs) {
-    return {
-      kind: "array-of-objects",
-      field: arrayOfObjs[1],
-      subfield: arrayOfObjs[2]
-    };
-  }
-  throw new Error(
-    `Token predicate cannot translate JSONPath "${jsonbPath}". Supported shapes: "$.field", "$.field[*]", "$.field[*].subfield".`
-  );
-}
-function parseTokenValue(raw) {
-  const idx = raw.indexOf("|");
-  if (idx === -1) {
-    return { code: raw };
-  }
-  const system = raw.slice(0, idx);
-  const code = raw.slice(idx + 1);
-  return system.length > 0 ? { system, code } : { code };
-}
-function wrapTokenInShape(shape, value) {
-  switch (shape.kind) {
-    case "scalar":
-      return { [shape.field]: value };
-    case "array-of-scalars":
-      return { [shape.field]: [value] };
-    case "array-of-objects":
-      return { [shape.field]: [{ [shape.subfield]: value }] };
-  }
-}
-function emitTokenPredicate(opts) {
-  const shape = jsonbPathToTokenShape(opts.jsonbPath);
-  const { code } = parseTokenValue(opts.rawValue);
-  const payload = wrapTokenInShape(shape, code);
-  const sql = `resource @> :${opts.paramName}::jsonb`;
-  const params = [
-    { name: opts.paramName, value: JSON.stringify(payload) }
-  ];
-  return { sql, params };
-}
-
-// src/data/search/engine/combinator.ts
-function parseQueryKey(key) {
-  const idx = key.indexOf(":");
-  if (idx === -1) {
-    return { code: key, modifier: void 0 };
-  }
-  return { code: key.slice(0, idx), modifier: key.slice(idx + 1) };
-}
-function flattenQueryValues(raw) {
-  const list = Array.isArray(raw) ? raw : [raw];
-  const out = [];
-  for (const v of list) {
-    for (const piece of v.split(",")) {
-      out.push(piece);
-    }
-  }
-  return out;
-}
-function parseQueryEntries(query) {
-  const entries = [];
-  for (const [rawKey, rawValue] of Object.entries(query)) {
-    if (rawValue === void 0) continue;
-    const { code, modifier } = parseQueryKey(rawKey);
-    entries.push({
-      code,
-      modifier,
-      values: flattenQueryValues(rawValue)
-    });
-  }
-  return entries;
-}
-function findParam(params, code) {
-  return params.find((p) => p.code === code);
-}
-function checkModifierAllowed(modifier, param) {
-  const universal = modifier === "missing" || modifier === "not";
-  const stringNative = param.type === "string" && (modifier === "exact" || modifier === "contains");
-  if (universal || stringNative) {
-    if (param.modifiers && !param.modifiers.includes(modifier)) {
-      throw new Error(
-        `Modifier ":${modifier}" is not in the allow-list for param "${param.code}".`
-      );
-    }
-    return;
-  }
-  throw new Error(
-    `Modifier ":${modifier}" is not recognized for param "${param.code}" (type "${param.type}").`
-  );
-}
-function emitOne(opts) {
-  const { param, modifier, rawValue, paramName, context } = opts;
-  if (modifier === "missing") {
-    const missing = parseMissingValue(rawValue);
-    return emitFieldMissingPredicate({
-      jsonbPath: param.jsonbPath,
-      missing
-    });
-  }
-  const negate = modifier === "not";
-  const effectiveModifier = negate ? void 0 : modifier;
-  const inner = emitForType({
-    paramType: param.type,
-    jsonbPath: param.jsonbPath,
-    rawValue,
-    paramName,
-    modifier: effectiveModifier,
-    context
-  });
-  if (!negate) {
-    return inner;
-  }
-  return { sql: `NOT (${inner.sql})`, params: inner.params };
-}
-function parseMissingValue(raw) {
-  if (raw === "true") return true;
-  if (raw === "false") return false;
-  throw new Error(
-    `:missing requires a value of "true" or "false"; received "${raw}".`
-  );
-}
-function emitForType(opts) {
-  switch (opts.paramType) {
-    case "token":
-      return emitTokenPredicate({
-        jsonbPath: opts.jsonbPath,
-        rawValue: opts.rawValue,
-        paramName: opts.paramName,
-        context: opts.context
-      });
-    case "date":
-      return emitDatePredicate({
-        jsonbPath: opts.jsonbPath,
-        rawValue: opts.rawValue,
-        paramName: opts.paramName,
-        context: opts.context
-      });
-    case "reference":
-      return emitReferencePredicate({
-        jsonbPath: opts.jsonbPath,
-        rawValue: opts.rawValue,
-        paramName: opts.paramName,
-        context: opts.context
-      });
-    case "string":
-      return emitStringPredicate({
-        jsonbPath: opts.jsonbPath,
-        rawValue: opts.rawValue,
-        paramName: opts.paramName,
-        modifier: opts.modifier,
-        context: opts.context
-      });
-  }
-}
-function combineSearchPredicates(opts) {
-  const entries = parseQueryEntries(opts.query);
-  const groupSqls = [];
-  const allParams = [];
-  let paramIdx = 0;
-  for (const entry of entries) {
-    const registered = findParam(opts.registeredParams, entry.code);
-    if (!registered) {
-      continue;
-    }
-    if (entry.modifier !== void 0) {
-      checkModifierAllowed(entry.modifier, registered);
-    }
-    if (entry.values.length === 0) {
-      continue;
-    }
-    const fragmentSqls = [];
-    let valueIdx = 0;
-    for (const rawValue of entry.values) {
-      const paramName = `p${paramIdx}v${valueIdx}`;
-      const frag = emitOne({
-        param: registered,
-        modifier: entry.modifier,
-        rawValue,
-        paramName,
-        context: opts.context
-      });
-      fragmentSqls.push(frag.sql);
-      for (const p of frag.params) {
-        allParams.push(p);
-      }
-      valueIdx++;
-    }
-    paramIdx++;
-    if (fragmentSqls.length === 1) {
-      groupSqls.push(fragmentSqls[0]);
-    } else {
-      groupSqls.push(`(${fragmentSqls.join(" OR ")})`);
-    }
-  }
-  if (groupSqls.length === 0) {
-    return { sql: "", params: [] };
+      body: patient
+    });
+    return res.status(201).location(`${BASE_PATH.PATIENT}/${result.id}`).json(result.resource);
+  } catch (err) {
+    return sendOperationOutcome500(res, err, "POST Patient error:");
   }
-  return { sql: groupSqls.join(" AND "), params: allParams };
 }
 
-// src/data/search/operations/generic-search-operation.ts
-var DEFAULT_LIMIT7 = 100;
-function buildGenericSearchSql(opts) {
-  const lines = [
-    "SELECT resource_id AS id, resource",
-    "FROM resources",
-    "WHERE tenant_id = :tenantId",
-    "  AND workspace_id = :workspaceId",
-    "  AND resource_type = :resourceType",
-    "  AND deleted_at IS NULL"
-  ];
-  if (opts.combinedSql.length > 0) {
-    lines.push(`  AND (${opts.combinedSql})`);
+// src/data/operations/data/patient/patient-delete-operation.ts
+async function deletePatientOperation(params) {
+  const { context, id, tableName } = params;
+  const { tenantId, workspaceId } = context;
+  const service = getDynamoDataService(tableName);
+  await deleteDataEntityById(
+    service.entities.patient,
+    tenantId,
+    workspaceId,
+    id
+  );
+}
+
+// src/data/rest-api/routes/data/patient/patient-delete-route.ts
+async function deletePatientRoute(req, res) {
+  const id = String(req.params.id);
+  const ctx = req.openhiContext;
+  try {
+    await deletePatientOperation({ context: ctx, id });
+    return res.status(204).send();
+  } catch (err) {
+    return sendOperationOutcome500(res, err, "DELETE Patient error:");
   }
-  lines.push("ORDER BY last_updated DESC");
-  lines.push("LIMIT :limit;");
-  return lines.join("\n");
 }
-async function genericSearchOperation(params) {
-  const { resourceType, tenantId, workspaceId, query, resolver } = params;
-  const runner = params.runner ?? getDefaultPostgresQueryRunner();
-  const limit = params.limit ?? DEFAULT_LIMIT7;
-  const registeredParams = resolver(resourceType, tenantId);
-  const context = { tenantId, workspaceId, resourceType };
-  const combined = combineSearchPredicates({
-    query,
-    registeredParams,
-    context
-  });
-  const sql = buildGenericSearchSql({ combinedSql: combined.sql });
-  const queryParams = [
-    { name: "tenantId", value: tenantId },
-    { name: "workspaceId", value: workspaceId },
-    { name: "resourceType", value: resourceType },
-    { name: "limit", value: limit },
-    ...combined.params
-  ];
-  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/patient/patient-get-by-id-operation.ts
+async function getPatientByIdOperation(params) {
+  const { context, id, tableName } = params;
+  const { tenantId, workspaceId } = context;
+  const service = getDynamoDataService(tableName);
+  return getDataEntityById(
+    service.entities.patient,
+    tenantId,
+    workspaceId,
+    id,
+    "Patient"
+  );
 }
 
-// src/data/search/registry/patient-search-parameters.ts
-var PATIENT_SEARCH_PARAMETERS = [
-  { code: "gender", type: "token", jsonbPath: "$.gender" },
-  { code: "identifier", type: "token", jsonbPath: "$.identifier[*].value" },
-  { code: "birthdate", type: "date", jsonbPath: "$.birthDate" },
-  {
-    code: "name",
-    type: "string",
-    jsonbPath: "$.name[*].text",
-    modifiers: ["exact", "contains", "missing", "not"]
-  },
-  {
-    code: "family",
-    type: "string",
-    jsonbPath: "$.name[*].family",
-    modifiers: ["exact", "contains", "missing", "not"]
-  },
-  {
-    code: "given",
-    type: "string",
-    jsonbPath: "$.name[*].given",
-    modifiers: ["exact", "contains", "missing", "not"]
-  },
-  { code: "active", type: "token", jsonbPath: "$.active" },
-  { code: "deceased", type: "token", jsonbPath: "$.deceasedBoolean" },
-  {
-    code: "general-practitioner",
-    type: "reference",
-    jsonbPath: "$.generalPractitioner[*]"
-  },
-  {
-    code: "organization",
-    type: "reference",
-    jsonbPath: "$.managingOrganization"
+// src/data/rest-api/routes/data/patient/patient-get-by-id-route.ts
+async function getPatientByIdRoute(req, res) {
+  const id = String(req.params.id);
+  const ctx = req.openhiContext;
+  try {
+    const result = await getPatientByIdOperation({ context: ctx, id });
+    return res.json(result.resource);
+  } catch (err) {
+    const status = domainErrorToHttpStatus(err);
+    if (status === 404) {
+      const diagnostics = err instanceof NotFoundError ? err.message : `Patient ${id} not found`;
+      return sendOperationOutcome404(res, diagnostics);
+    }
+    return sendOperationOutcome500(res, err, "GET Patient error:");
   }
-];
+}
 
-// src/data/search/registry/resolver.ts
-var STATIC_SEARCH_PARAMETER_MAP = {
-  Patient: PATIENT_SEARCH_PARAMETERS
-};
-var defaultSearchParameterResolver = (resourceType, _tenantId) => STATIC_SEARCH_PARAMETER_MAP[resourceType] ?? [];
-function getRegisteredSearchParameters(resourceType) {
-  return STATIC_SEARCH_PARAMETER_MAP[resourceType] ?? [];
+// src/data/operations/data/patient/patient-list-operation.ts
+async function listPatientsOperation(params) {
+  const { context, tableName, mode } = params;
+  const { tenantId, workspaceId } = context;
+  const service = getDynamoDataService(tableName);
+  return listDataEntitiesByWorkspace(
+    service.entities.patient,
+    tenantId,
+    workspaceId,
+    mode
+  );
 }
 
 // src/data/rest-api/routes/data/patient/patient-list-route.ts
 var PATIENT_RESOURCE_TYPE = "Patient";
-function stripModifier(key) {
+function stripModifier4(key) {
   const idx = key.indexOf(":");
   return idx === -1 ? key : key.slice(0, idx);
 }
-function isResultParameter(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 extractSearchParamKeys(query) {
+function extractSearchParamKeys4(query) {
   const out = [];
   for (const rawKey of Object.keys(query)) {
-    if (isResultParameter(rawKey)) {
+    if (isResultParameter4(rawKey)) {
       continue;
     }
-    out.push({ rawKey, code: stripModifier(rawKey) });
+    out.push({ rawKey, code: stripModifier4(rawKey) });
   }
   return out;
 }
-function buildUnknownParamDiagnostics(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;
@@ -25993,7 +25677,7 @@ function buildUnknownParamDiagnostics(unknownCodes) {
     `Valid codes: ${validCodes}.`
   ].join(" ");
 }
-function findMalformedReference(query, searchParamKeys) {
+function findMalformedReference4(query, searchParamKeys) {
   const referenceCodes = new Set(
     getRegisteredSearchParameters(PATIENT_RESOURCE_TYPE).filter((p) => p.type === "reference").map((p) => p.code)
   );
@@ -26016,7 +25700,7 @@ function findMalformedReference(query, searchParamKeys) {
   return void 0;
 }
 async function listPatientsRoute(req, res) {
-  const searchParamKeys = extractSearchParamKeys(
+  const searchParamKeys = extractSearchParamKeys4(
     req.query
   );
   if (searchParamKeys.length === 0) {
@@ -26032,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,
-      buildUnknownParamDiagnostics([...new Set(unknownCodes)])
+      buildUnknownParamDiagnostics4([...new Set(unknownCodes)])
     );
   }
-  const malformedRef = findMalformedReference(
+  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}".`
     );
@@ -27381,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) {
@@ -29845,7 +29622,7 @@ async function listSchedulesOperation(params) {
 }
 
 // src/data/operations/data/schedule/schedule-search-by-actor-operation.ts
-var DEFAULT_LIMIT8 = 100;
+var DEFAULT_LIMIT2 = 100;
 function buildSearchSchedulesByActorSql() {
   return [
     "SELECT resource_id AS id, resource",
@@ -29863,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_LIMIT8;
+  const limit = params.limit ?? DEFAULT_LIMIT2;
   const { containmentRelative, containmentUrn } = buildReferenceContainmentPayload({
     shape: { kind: "array-of-references", field: "actor" },
     reference: actorReference,
@@ -29889,7 +29666,7 @@ async function searchSchedulesByActorOperation(params) {
 }
 
 // src/data/rest-api/routes/data/schedule/schedule-list-route.ts
-function singleStringQueryParam3(req, name) {
+function singleStringQueryParam(req, name) {
   const v = req.query[name];
   if (typeof v !== "string") {
     return void 0;
@@ -29897,17 +29674,17 @@ function singleStringQueryParam3(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 = singleStringQueryParam3(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}".`
       );
@@ -33609,7 +33386,7 @@ async function listTasksOperation(params) {
 }
 
 // src/data/operations/data/task/task-search-by-owner-operation.ts
-var DEFAULT_LIMIT9 = 100;
+var DEFAULT_LIMIT3 = 100;
 function buildSearchTasksByOwnerSql() {
   return [
     "SELECT resource_id AS id, resource",
@@ -33627,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_LIMIT9;
+  const limit = params.limit ?? DEFAULT_LIMIT3;
   const { containmentRelative, containmentUrn } = buildReferenceContainmentPayload({
     shape: { kind: "scalar", field: "owner" },
     reference: ownerReference,
@@ -33653,7 +33430,7 @@ async function searchTasksByOwnerOperation(params) {
 }
 
 // src/data/operations/data/task/task-search-by-requester-operation.ts
-var DEFAULT_LIMIT10 = 100;
+var DEFAULT_LIMIT4 = 100;
 function buildSearchTasksByRequesterSql() {
   return [
     "SELECT resource_id AS id, resource",
@@ -33671,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_LIMIT10;
+  const limit = params.limit ?? DEFAULT_LIMIT4;
   const { containmentRelative, containmentUrn } = buildReferenceContainmentPayload({
     shape: { kind: "scalar", field: "requester" },
     reference: requesterReference,
@@ -33697,7 +33474,7 @@ async function searchTasksByRequesterOperation(params) {
 }
 
 // src/data/rest-api/routes/data/task/task-list-route.ts
-function singleStringQueryParam4(req, name) {
+function singleStringQueryParam2(req, name) {
   const v = req.query[name];
   if (typeof v !== "string") {
     return void 0;
@@ -33705,24 +33482,24 @@ function singleStringQueryParam4(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 = singleStringQueryParam4(req, "owner");
-  const requesterRef = singleStringQueryParam4(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}".`
       );
@@ -33745,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}".`
       );