refactor(types): clear backboneSliceTyping and sliceDelegation

257 -> 237.

backboneSliceTyping: the slice-group field name comes from at(-1) with a skip,
replacing a non-null assertion; the union collapse destructures its sole member;
the root-interface update and the type-alias conversion each hoist the entry once
instead of re-indexing it four times; the choice-parent capture and the root
segment go through optional access and firstSegment.

sliceDelegation: the delegation discriminator returns when handed an empty
fixed-value list, the Reference target url is read through optional indexing
instead of a length test, and two more split idioms go through firstSegment.

These were written while the shell was unavailable, so they were reviewed by
reading before they could be compiled — which caught one real break: removing
`const segments = relativePath.split('.')` left a later
`segments.slice(1).join('.')` referring to nothing. Restored, and the compiler
agrees now.

us-core HL7 replay 54/54 random and 54/54 empty; typecheck, lint and 769 tests
green.

Author: quotentiroler

src/generator/emitters/interface/backboneSliceTyping.ts

@@ -20,7 +20,7 @@
  */
 
 import type { Field } from '../../core/sdTypes.js';
-import { capitalize, choicePropertyName, narrowedChoiceType, sanitizeIdentifier } from '../../core/utils.js';
+import { capitalize, choicePropertyName, narrowedChoiceType, sanitizeIdentifier, firstSegment } from '../../core/utils.js';
 import { getRules } from '../../fhir/versionContext.js';
 import type { ImportManager } from './importManager.js';
 import { logger } from '../../../logger.js';
@@ -62,7 +62,10 @@ export function generateBackboneSliceTypes(ctx: BackboneSliceTypingContext): voi
 
   for (const group of sliceGroups) {
     const { parentField, sliceFields, childFields, slicingRules } = group;
-    const fieldName = parentField.name.split('.').pop()!;
+    const fieldName = parentField.name.split('.').at(-1);
+    // A grouped parent always has a dotted path, so this is unreachable; skipping
+    // is right if it ever is not, and it replaces a non-null assertion.
+    if (!fieldName) continue;
 
     // Determine the base backbone type for this field
     let backboneType = inferBackboneType(baseResource, fieldName);
@@ -138,8 +141,9 @@ export function generateBackboneSliceTypes(ctx: BackboneSliceTypingContext): voi
     if (isOpen) {
       unionMembers.push(backboneType);
     }
-    const unionType = unionMembers.length === 1
-      ? `${unionMembers[0]}[]`
+    const [soleMember] = unionMembers;
+    const unionType = unionMembers.length === 1 && soleMember
+      ? `${soleMember}[]`
       : `(${unionMembers.join(' | ')})[]`;
 
     // Find and update the field in the root interface
@@ -222,7 +226,7 @@ function isEligibleBackbonePath(baseType: string, path: string, baseResource: st
   // Must be a root-level field (direct child of the base resource)
   const parts = path.split('.');
   if (parts.length !== 2) return false;
-  if (baseResource && parts[0] !== baseResource) return false;
+  if (baseResource && firstSegment(path) !== baseResource) return false;
 
   return true;
 }
@@ -284,9 +288,10 @@ function buildSliceInterfaceBody(
     const childId = child.elementId || child.name;
     const relativePath = childId.substring(sliceElementId.length + 1);
     const match = choiceSlicePattern.exec(relativePath);
-    if (match) {
+    const choiceParent = match?.[1]; // e.g. "value[x]"
+    if (choiceParent) {
       choiceTypeSlices.push(child);
-      choiceTypeParents.add(match[1]); // e.g. "value[x]"
+      choiceTypeParents.add(choiceParent);
     }
   }
 
@@ -303,7 +308,9 @@ function buildSliceInterfaceBody(
     if (relativePath.includes('.')) {
       if (child.fixedValue !== undefined) {
         const segments = relativePath.split('.');
-        const rawPropName = segments[0];
+        // firstSegment is segments[0] without the possibly-undefined read; segments
+        // is still needed for the tail below.
+        const rawPropName = firstSegment(relativePath);
         const propName = rawPropName.replace(/\[x\]$/, '');
         // Skip nested values under:
         // - choice-type elements ([x]) — handled by direct child or sub-slices
@@ -495,8 +502,8 @@ function updateRootInterfaceField(
     i.startsWith(`export interface ${interfaceName} `) || i.startsWith(`export interface ${interfaceName}<`),
   );
 
-  if (rootIdx >= 0) {
-    const iface = interfaces[rootIdx];
+  const iface = rootIdx >= 0 ? interfaces[rootIdx] : undefined;
+  if (iface !== undefined) {
     const fieldPattern = new RegExp(`^(\\s+)${fieldName}[?]?:\\s*.+;`, 'm');
 
     if (fieldPattern.test(iface)) {
@@ -517,10 +524,10 @@ function updateRootInterfaceField(
     i.startsWith(`export type ${interfaceName} =`),
   );
 
-  if (aliasIdx >= 0) {
+  const alias = aliasIdx >= 0 ? interfaces[aliasIdx] : undefined;
+  if (alias !== undefined) {
     // Convert type alias to interface with the field
-    const aliasMatch = interfaces[aliasIdx].match(/export type \S+ = (\S+);/);
-    const baseType = aliasMatch ? aliasMatch[1] : baseResource || '';
+    const baseType = alias.match(/export type \S+ = (\S+);/)?.[1] ?? baseResource ?? '';
     interfaces[aliasIdx] = `export interface ${interfaceName} extends ${baseType} {\n${newFieldLine}\n}`;
   }
 }

src/generator/emitters/validator/sliceDelegation.ts

@@ -9,7 +9,7 @@
 
 import type { Field } from '../../core/sdTypes.js';
 import type { DatatypeProfilePin } from './validatorTypes.js';
-import { stripVersionFromCanonicalUrl } from '../../core/utils.js';
+import { stripVersionFromCanonicalUrl, firstSegment } from '../../core/utils.js';
 // Type-only, so the mutual reference with sliceValidatorGenerator carries no
 // runtime cycle.
 import type { SliceValidationContext } from './sliceValidatorGenerator.js';
@@ -39,10 +39,11 @@ export function generateProfiledChildDelegation(
 
   // Get discriminator info to build the filter expression
   const discriminatorChild = childFieldsWithFixedValue[0];
+  if (!discriminatorChild) return;
   const childFieldId = (discriminatorChild.elementId || discriminatorChild.name).replace(/^[^.]+\./, '');
   let discriminatorProp = '';
   if (childFieldId.startsWith(sliceElemId + '.')) {
-    discriminatorProp = childFieldId.substring(sliceElemId.length + 1).split('.')[0];
+    discriminatorProp = firstSegment(childFieldId.substring(sliceElemId.length + 1));
   }
   if (!discriminatorProp) return;
 
@@ -170,8 +171,8 @@ export function detectReferenceProfileDiscriminator(
 ): string | undefined {
   if (!slice.typeOptions?.length) return undefined;
   const refType = slice.typeOptions.find(t => t.code === 'Reference');
-  if (!refType?.targetProfileUrls?.length) return undefined;
-  const targetUrl = refType.targetProfileUrls[0];
+  const targetUrl = refType?.targetProfileUrls?.[0];
+  if (!targetUrl) return undefined;
   // 1. Authoritative: resolve from profileUrlToType map
   if (profileUrlToType) {
     const resolved = profileUrlToType.get(targetUrl);
@@ -215,7 +216,7 @@ export function generateReferenceProfileDiscriminatorValidation(
 ): void {
   // Build within-slice child max constraint checks (e.g., max=0 forbidden fields)
   const maxChildren = fields ? collectWithinSliceMaxChildren(slice, fields) : [] as ReturnType<typeof collectWithinSliceMaxChildren>;
-  const resType = baseResourceType || (slice.elementId || slice.name).split('.')[0];
+  const resType = baseResourceType || firstSegment(slice.elementId || slice.name);
   const childMaxChecks = generateWithinSliceMaxChecks(maxChildren, `_${varName}Refs`, resType, relPath, sliceLabel);
 
   out.push(`
@@ -404,7 +405,7 @@ export function detectProfileDiscriminator(
 
   // 2. Try to extract from profile URL last segment (core profiles)
   const profileUrl = profileUrls[0];
-  const lastSegment = profileUrl.split('/').pop() || '';
+  const lastSegment = profileUrl?.split('/').pop() || '';
   if (/^[A-Z][a-zA-Z]+$/.test(lastSegment)) {
     return { resourceType: lastSegment, profileUrls };
   }