babelfhir-ts 1.5.2 → 1.5.3

package/out/src/generator/emitters/interface/backboneSliceTyping.js

@@ -0,0 +1,298 @@
+/**
+ * Backbone slice typing: generates discriminated union types for sliced backbone elements.
+ *
+ * When a profile defines named slices on a backbone element array (e.g., Observation.component),
+ * this module generates per-slice interfaces extending the base backbone type and updates
+ * the parent array field to use a union of those interfaces.
+ *
+ * Example output for BloodPressure.component with systolic/diastolic slices:
+ * ```ts
+ * export interface BloodPressureComponentSystolic extends ObservationComponent {
+ *   code: { coding: [{ system: "http://loinc.org"; code: "8480-6" }] };
+ * }
+ * export interface BloodPressureComponentDiastolic extends ObservationComponent {
+ *   code: { coding: [{ system: "http://loinc.org"; code: "8462-4" }] };
+ * }
+ * export interface BloodPressure extends Observation {
+ *   component?: (BloodPressureComponentSystolic | BloodPressureComponentDiastolic | ObservationComponent)[];
+ * }
+ * ```
+ */
+import { capitalize, sanitizeIdentifier } from '../../core/utils.js';
+import { getRules } from '../../fhir/versionContext.js';
+import { logger } from '../../../logger.js';
+const log = logger.withTag('backbone-slices');
+/**
+ * Post-process backbone element slices: generate per-slice interfaces and update
+ * the parent array property to a union type.
+ */
+export function generateBackboneSliceTypes(ctx) {
+    const { interfaceName, baseResource, newFields, baseFields, interfaces, importManager, inferBackboneType } = ctx;
+    const rules = getRules();
+    // 1. Find all sliced backbone element arrays
+    const sliceGroups = collectSliceGroups(newFields, baseResource);
+    if (sliceGroups.length === 0)
+        return;
+    for (const group of sliceGroups) {
+        const { parentField, sliceFields, childFields, slicingRules } = group;
+        const fieldName = parentField.name.split('.').pop();
+        // Determine the base backbone type for this field
+        let backboneType = inferBackboneType(baseResource, fieldName);
+        if (!backboneType) {
+            // Try from base fields — only accept concrete FHIR types that we can
+            // actually extend (not 'BackboneElement', 'Element', 'any', or unknown types).
+            // BackboneElement/Element are too generic: the parent field expects a specific
+            // subtype (e.g. ExplanationOfBenefitItemAdjudication) and extending the raw
+            // generic type produces TS2430.
+            const baseFld = baseFields.find(f => f.name === parentField.name && !f.sliceName);
+            const rawType = baseFld?.type || parentField.type;
+            if (rawType && rawType !== 'BackboneElement' && rawType !== 'Element' && rules.isFhirType(rawType)) {
+                backboneType = rawType;
+            }
+        }
+        if (!backboneType) {
+            log.debug(`No backbone type found for ${parentField.name}, skipping slice typing`);
+            continue;
+        }
+        // Ensure the backbone type is imported
+        if (rules.isFhirType(backboneType)) {
+            importManager.addFhirType(backboneType);
+        }
+        // 2. Generate per-slice interfaces
+        const sliceTypeNames = [];
+        for (const sliceField of sliceFields) {
+            const sliceName = sliceField.sliceName;
+            const sliceTypeName = `${interfaceName}${capitalize(fieldName)}${capitalize(sanitizeIdentifier(sliceName))}`;
+            // Collect children for this specific slice
+            const sliceElementId = sliceField.elementId || `${parentField.name}:${sliceName}`;
+            const sliceChildren = childFields.filter(f => {
+                const childId = f.elementId || f.name;
+                return childId.startsWith(sliceElementId + '.');
+            });
+            // Build interface body lines from slice children and the slice's own constraints
+            const { lines: bodyLines, referencedFhirTypes } = buildSliceInterfaceBody(sliceField, sliceChildren, sliceElementId, backboneType);
+            if (bodyLines.length === 0) {
+                // No constrainable properties — skip this slice interface
+                log.debug(`No constraints for slice ${sliceName} of ${parentField.name}, skipping`);
+                continue;
+            }
+            // Register any FHIR types used in the slice body
+            for (const fhirType of referencedFhirTypes) {
+                importManager.addFhirType(fhirType);
+            }
+            // Emit the slice interface
+            const sliceInterface = `export interface ${sliceTypeName} extends ${backboneType} {\n${bodyLines.map(l => `    ${l}`).join('\n')}\n}`;
+            // Add before the root interface to maintain declaration order
+            const rootIdx = interfaces.findIndex(i => i.startsWith(`export interface ${interfaceName} `) || i.startsWith(`export interface ${interfaceName}<`));
+            if (rootIdx >= 0) {
+                interfaces.splice(rootIdx, 0, sliceInterface);
+            }
+            else {
+                interfaces.push(sliceInterface);
+            }
+            sliceTypeNames.push(sliceTypeName);
+        }
+        if (sliceTypeNames.length === 0)
+            continue;
+        // 3. Update the parent field's type in the root interface to use the union
+        const isOpen = slicingRules !== 'closed';
+        const unionMembers = [...sliceTypeNames];
+        if (isOpen) {
+            unionMembers.push(backboneType);
+        }
+        const unionType = unionMembers.length === 1
+            ? `${unionMembers[0]}[]`
+            : `(${unionMembers.join(' | ')})[]`;
+        // Find and update the field in the root interface
+        updateRootInterfaceField(interfaces, interfaceName, fieldName, parentField.isOptional, unionType, baseResource);
+    }
+}
+/**
+ * Collect sliced backbone element groups from the fields.
+ */
+function collectSliceGroups(fields, baseResource) {
+    const groups = [];
+    const seenPaths = new Set();
+    for (const field of fields) {
+        if (field.sliceName)
+            continue; // Skip slice entries themselves
+        if (!field.isArray)
+            continue; // Slicing is only on arrays
+        const path = field.name;
+        if (seenPaths.has(path))
+            continue;
+        // Check if there are named slices at this path
+        const sliceFields = fields.filter(f => f.name === path && f.sliceName);
+        if (sliceFields.length === 0)
+            continue;
+        // Must be a true backbone element — only process fields whose base FHIR type
+        // is BackboneElement or Element (inline nested types). Skip complex DataTypes
+        // like Identifier, CodeableConcept, ContactPoint, etc. — those have slices
+        // handled by the main type mapping and profiled type reference system.
+        const baseType = field.baseTypeCode || field.type || '';
+        if (baseType !== 'BackboneElement' && baseType !== 'Element')
+            continue;
+        // Skip extension slices — handled separately by postProcessExtensions
+        const fieldName = path.split('.').pop() || '';
+        if (fieldName === 'extension' || fieldName === 'modifierExtension')
+            continue;
+        // Skip Bundle.entry and similar resource-container slices — these use profiled
+        // type references that are handled by the external profile resolution system
+        if (fieldName === 'entry')
+            continue;
+        // Must be a root-level field (direct child of the base resource)
+        const parts = path.split('.');
+        if (parts.length !== 2)
+            continue;
+        if (baseResource && parts[0] !== baseResource)
+            continue;
+        // Gather all child fields for any slice of this element
+        const childFields = fields.filter(f => {
+            if (f.name === path)
+                return false; // Skip the parent itself
+            const childId = f.elementId || f.name;
+            // Match children that belong to ANY slice of this element
+            return childId.startsWith(`${path}:`) || (f.name.startsWith(`${path}.`) && f.name !== path);
+        });
+        // Determine slicing rules from the parent field's metadata
+        // The slicing rules come from the SD's element.slicing.rules
+        // We default to 'open' since that's the FHIR default
+        const slicingRules = field.slicingRules || 'open';
+        seenPaths.add(path);
+        groups.push({ parentField: field, sliceFields, childFields, slicingRules });
+    }
+    return groups;
+}
+/**
+ * Build the body lines for a slice-specific interface.
+ */
+function buildSliceInterfaceBody(sliceField, sliceChildren, sliceElementId, _backboneType) {
+    const lines = [];
+    const referencedFhirTypes = [];
+    // Add pattern constraint from the slice field itself (discriminator value)
+    if (sliceField.patternConstraint && typeof sliceField.patternConstraint === 'object') {
+        const pattern = sliceField.patternConstraint;
+        if ('coding' in pattern && Array.isArray(pattern.coding)) {
+            // patternCodeableConcept on the slice itself (rare — usually on a child like .code)
+            const codingLiteral = formatCodingLiteral(pattern.coding);
+            if (codingLiteral) {
+                lines.push(`coding: ${codingLiteral};`);
+            }
+        }
+    }
+    // Process direct children of the slice
+    for (const child of sliceChildren) {
+        const childId = child.elementId || child.name;
+        const relativePath = childId.substring(sliceElementId.length + 1);
+        // Only handle direct children (no dots in relative path)
+        if (relativePath.includes('.'))
+            continue;
+        // Skip slice notation in child paths
+        if (relativePath.includes(':'))
+            continue;
+        const propName = relativePath.replace(/\[x\]$/, '');
+        if (child.fixedValue !== undefined) {
+            // Fixed value constraint
+            const fixedLiteral = JSON.stringify(child.fixedValue);
+            lines.push(`${propName}: ${child.isArray ? `[${fixedLiteral}]` : fixedLiteral};`);
+        }
+        else if (child.patternConstraint && typeof child.patternConstraint === 'object') {
+            const pattern = child.patternConstraint;
+            if ('coding' in pattern && Array.isArray(pattern.coding)) {
+                // patternCodeableConcept
+                const codingLiteral = formatCodingLiteral(pattern.coding);
+                if (codingLiteral) {
+                    const objectLiteral = `{ coding: ${codingLiteral} }`;
+                    lines.push(`${propName}: ${child.isArray ? `[${objectLiteral}]` : objectLiteral};`);
+                }
+            }
+            else if ('code' in pattern && typeof pattern.code === 'string') {
+                // patternCoding
+                const parts = [];
+                if ('system' in pattern && typeof pattern.system === 'string') {
+                    parts.push(`system: "${pattern.system}"`);
+                }
+                parts.push(`code: "${pattern.code}"`);
+                const objectLiteral = `{ ${parts.join('; ')} }`;
+                lines.push(`${propName}: ${child.isArray ? `[${objectLiteral}]` : objectLiteral};`);
+            }
+        }
+        else if (!child.isOptional && child.type) {
+            // Required field without constraints — mark as required in the interface.
+            // Skip children whose type can't produce a valid extends:
+            // - BackboneElement/Element: parent expects a concrete subtype
+            // - 'any': unresolvable type (e.g. content references like Parameters.parameter.part)
+            //   that mapTypeToTS would map to 'string', producing an incompatible field.
+            if (child.type === 'BackboneElement' || child.type === 'Element' || child.type === 'any')
+                continue;
+            const rawType = getRules().mapTypeToTS(child.type);
+            const mappedType = sanitizeIdentifier(rawType);
+            // Skip profiled type references that would need separate imports
+            // (e.g., Composition-uv-ips) — these are better handled by the main processor
+            if (mappedType !== rawType && child.isProfiled)
+                continue;
+            const isArray = child.isArray ? '[]' : '';
+            lines.push(`${propName}: ${mappedType}${isArray};`);
+            // Track FHIR types that need importing
+            if (getRules().isFhirType(mappedType)) {
+                referencedFhirTypes.push(mappedType);
+            }
+        }
+    }
+    return { lines, referencedFhirTypes };
+}
+/**
+ * Format an array of coding objects as a TypeScript literal type.
+ */
+function formatCodingLiteral(codings) {
+    const entries = [];
+    for (const coding of codings) {
+        if (!coding || typeof coding !== 'object')
+            continue;
+        const c = coding;
+        const parts = [];
+        if (typeof c.system === 'string')
+            parts.push(`system: "${c.system}"`);
+        if (typeof c.code === 'string')
+            parts.push(`code: "${c.code}"`);
+        if (parts.length > 0) {
+            entries.push(`{ ${parts.join('; ')} }`);
+        }
+    }
+    if (entries.length === 0)
+        return null;
+    return `[${entries.join(', ')}]`;
+}
+/**
+ * Update the root interface to use the union type for a sliced backbone field.
+ */
+function updateRootInterfaceField(interfaces, interfaceName, fieldName, isOptional, unionType, baseResource) {
+    const optMark = isOptional ? '?' : '';
+    const newFieldLine = `    ${fieldName}${optMark}: ${unionType};`;
+    // Try to find an existing interface declaration
+    const rootIdx = interfaces.findIndex(i => i.startsWith(`export interface ${interfaceName} `) || i.startsWith(`export interface ${interfaceName}<`));
+    if (rootIdx >= 0) {
+        const iface = interfaces[rootIdx];
+        const fieldPattern = new RegExp(`^(\\s+)${fieldName}[?]?:\\s*.+;`, 'm');
+        if (fieldPattern.test(iface)) {
+            // Replace existing field line
+            interfaces[rootIdx] = iface.replace(fieldPattern, newFieldLine);
+        }
+        else {
+            // Field not yet in the interface — inject it before the closing brace
+            const closingBrace = iface.lastIndexOf('}');
+            if (closingBrace > 0) {
+                interfaces[rootIdx] = iface.slice(0, closingBrace) + newFieldLine + '\n' + iface.slice(closingBrace);
+            }
+        }
+        return;
+    }
+    // Try to find a type alias (e.g., "export type BloodPressure = Observation;")
+    const aliasIdx = interfaces.findIndex(i => i.startsWith(`export type ${interfaceName} =`));
+    if (aliasIdx >= 0) {
+        // Convert type alias to interface with the field
+        const aliasMatch = interfaces[aliasIdx].match(/export type \S+ = (\S+);/);
+        const baseType = aliasMatch ? aliasMatch[1] : baseResource || '';
+        interfaces[aliasIdx] = `export interface ${interfaceName} extends ${baseType} {\n${newFieldLine}\n}`;
+    }
+}

package/out/src/generator/emitters/interface/interfaceGenerator.js

@@ -6,6 +6,7 @@ import { ImportManager } from './importManager.js';
 import { getRules, ctx as versionCtx } from '../../fhir/versionContext.js';
 import { postProcessExtensions, safetyNetRootExtensions } from './postProcessExtensions.js';
 import { processFields } from './interfaceFieldProcessor.js';
+import { generateBackboneSliceTypes } from './backboneSliceTyping.js';
 const log = logger.withTag('interfaces');
 export function generateInterfaces(interfaceName, newFields, baseResource, baseFields = [], valueSets, resourceType, existingProfiles, fhirChildTypeMap, profileIdToName, profileUrlToName, isLogicalModel = false) {
     const debug = (...args) => log.debug(...args);
@@ -243,6 +244,17 @@ export function generateInterfaces(interfaceName, newFields, baseResource, baseF
             interfaces.push(`export interface ${interfaceName} {}`);
         }
     }
+    // Post-pass: generate discriminated union types for sliced backbone elements.
+    // Must run after type alias generation so it can convert aliases to interfaces if needed.
+    generateBackboneSliceTypes({
+        interfaceName,
+        baseResource,
+        newFields,
+        baseFields,
+        interfaces,
+        importManager,
+        inferBackboneType,
+    });
     // Generate import statements using ImportManager
     const importStatements = importManager.generateImportStatements();
     let output = `${importStatements}\n${interfaces.join("\n\n")}`;

package/out/src/generator/emitters/zod/zodRefinementBuilder.js

@@ -1,6 +1,8 @@
 /**
- * Zod refinement builder for pattern constraints, slice cardinalities, and FHIRPath invariants.
+ * Zod refinement builder for pattern constraints, slice cardinalities, FHIRPath invariants,
+ * and required ValueSet bindings.
  */
+import { sanitizeValueSetName } from '../valueset/valueSetGenerator.js';
 /** Escape double-quote characters in refinement messages */
 function escStr(s) {
     return s.replace(/"/g, '\\"');
@@ -9,8 +11,9 @@ function escStr(s) {
  * Build refinement chains for pattern constraints, required slice cardinalities,
  * and FHIRPath invariants. Returns refinement code strings plus tracked constraint metadata.
  */
-export function buildRefinements(allFields, rootPrefix) {
+export function buildRefinements(allFields, rootPrefix, valueSets) {
     const refinements = [];
+    const bindingVsImports = new Map();
     // Build set of direct (root-level) field names for safety checks
     const directFieldNames = new Set();
     for (const field of allFields) {
@@ -176,5 +179,69 @@ export function buildRefinements(allFields, rootPrefix) {
             refinements.push(`.refine(d => (d as any).meta?.${subField} !== undefined, { message: "meta.${subField} must be present", when: () => true })`);
         }
     }
-    return { refinements, supportedConstraints, unsupportedConstraints };
+    // 5. Required ValueSet bindings on CodeableConcept / Coding fields
+    // When a field has binding.strength === 'required' and we have resolved codes,
+    // emit a refinement that checks at least one coding.code is in the allowed set.
+    for (const field of allFields) {
+        const parts = field.name.split('.');
+        if (parts.length !== 2 || parts[0] !== rootPrefix)
+            continue;
+        if (field.sliceName)
+            continue;
+        const type = field.type || field.baseTypeCode || '';
+        if (type !== 'CodeableConcept' && type !== 'Coding')
+            continue;
+        if (field.binding?.strength !== 'required')
+            continue;
+        const rel = parts[1];
+        // Skip choice-type placeholders (code[x], value[x], etc.) — the binding applies
+        // to the resolved variant (e.g. codeCodeableConcept) which we cannot reliably
+        // identify here. Emitting d.code[x] would produce invalid TypeScript.
+        if (rel.includes('[x]'))
+            continue;
+        if (!directFieldNames.has(rel))
+            continue;
+        // Resolve codes: prefer field.binding.codes, then fall back to parsed ValueSets
+        let codes;
+        let vsDisplayName = '';
+        if (field.binding.codes && field.binding.codes.length > 0) {
+            codes = field.binding.codes.map(c => c.code);
+            vsDisplayName = field.binding.uri?.split('/').pop() || 'ValueSet';
+        }
+        else if (field.binding.uri && valueSets) {
+            const vsUri = field.binding.uri.split('|')[0];
+            const vs = valueSets.get(vsUri) || valueSets.get(field.binding.uri);
+            if (vs && vs.concepts.length > 0 && vs.concepts.length <= 200) {
+                codes = vs.concepts.map(c => c.code);
+                vsDisplayName = vs.name || vsUri.split('/').pop() || 'ValueSet';
+                // Import the ValueSet type so the codes are available at runtime
+                const sanitizedName = sanitizeValueSetName(vs.name);
+                bindingVsImports.set(sanitizedName, `./valuesets/ValueSet-${sanitizedName}.js`);
+            }
+        }
+        if (!codes || codes.length === 0)
+            continue;
+        const codesLiteral = `[${codes.map(c => JSON.stringify(c)).join(', ')}]`;
+        const msgBase = `None of the codings provided are in the value set '${escStr(vsDisplayName)}' (${escStr(field.binding.uri || '')})`;
+        if (type === 'CodeableConcept') {
+            if (field.isArray) {
+                // Array of CodeableConcept: each entry must have at least one valid coding
+                refinements.push(`.refine(d => { const arr = (d as any).${rel}; if (!Array.isArray(arr)) return true; const allowed = ${codesLiteral}; return arr.every((cc: any) => cc?.coding?.some((c: any) => allowed.includes(c?.code))); }, { message: "${escStr(msgBase)}", when: () => true })`);
+            }
+            else {
+                // Single CodeableConcept: coding must include at least one valid code
+                refinements.push(`.refine(d => { const cc = (d as any).${rel}; if (!cc) return true; const allowed = ${codesLiteral}; return cc.coding?.some((c: any) => allowed.includes(c?.code)); }, { message: "${escStr(msgBase)}", when: () => true })`);
+            }
+        }
+        else {
+            // Coding field
+            if (field.isArray) {
+                refinements.push(`.refine(d => { const arr = (d as any).${rel}; if (!Array.isArray(arr)) return true; const allowed = ${codesLiteral}; return arr.every((c: any) => allowed.includes(c?.code)); }, { message: "${escStr(msgBase)}", when: () => true })`);
+            }
+            else {
+                refinements.push(`.refine(d => { const c = (d as any).${rel}; if (!c) return true; const allowed = ${codesLiteral}; return allowed.includes(c.code); }, { message: "${escStr(msgBase)}", when: () => true })`);
+            }
+        }
+    }
+    return { refinements, supportedConstraints, unsupportedConstraints, valueSetImports: bindingVsImports };
 }

package/out/src/generator/emitters/zod/zodSchemaGenerator.js

@@ -249,13 +249,19 @@ export function generateZodSchema(interfaceName, newFields, baseResource, baseFi
     for (const [vsTypeName, vsPath] of valueSetImports) {
         lines.push(`import { ${vsTypeName} } from "${vsPath}";`);
     }
-    // Collect refinements (pattern constraints, slice cardinality, FHIRPath invariants)
+    // Collect refinements (pattern constraints, slice cardinality, FHIRPath invariants, required bindings)
     // Only emit refinements for Resource profiles (not DataType profiles like Identifier, Coding)
     // because DataType random() methods don't produce pattern-aware data.
     const isDataTypeProfile = getZodPackageTypes().has(rootPrefix);
     const refinementResult = isDataTypeProfile
-        ? { refinements: [], supportedConstraints: [], unsupportedConstraints: [] }
-        : buildRefinements(allFields, rootPrefix);
+        ? { refinements: [], supportedConstraints: [], unsupportedConstraints: [], valueSetImports: new Map() }
+        : buildRefinements(allFields, rootPrefix, valueSets);
+    // Merge ValueSet imports from binding refinements
+    for (const [name, importPath] of refinementResult.valueSetImports) {
+        if (!valueSetImports.has(name)) {
+            valueSetImports.set(name, importPath);
+        }
+    }
     lines.push('');
     // Emit schema
     const schemaName = `${interfaceName}Schema`;

package/out/src/generator/emitters/zod/zodStubInstaller.js

@@ -26,6 +26,20 @@ function findRepoRoot() {
     }
     return path.resolve(selfDir, '..', '..', '..', '..');
 }
+/** Recursively copy a directory's contents, handling nested subdirectories. */
+function copyDirRecursive(src, dest) {
+    for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+        const srcPath = path.join(src, entry.name);
+        const destPath = path.join(dest, entry.name);
+        if (entry.isDirectory()) {
+            fs.mkdirSync(destPath, { recursive: true });
+            copyDirRecursive(srcPath, destPath);
+        }
+        else {
+            fs.copyFileSync(srcPath, destPath);
+        }
+    }
+}
 export function installBaseZodTypes(outputDir) {
     const slug = versionSlug();
     const pkgDir = path.join(outputDir, 'node_modules', '@babelfhir-ts', 'zod');
@@ -42,9 +56,7 @@ export function installBaseZodTypes(outputDir) {
         // Copy all runtime dist files into dist/<slug>/ to match package.json exports
         const distSlugDir = path.join(pkgDir, 'dist', slug);
         fs.mkdirSync(distSlugDir, { recursive: true });
-        for (const file of fs.readdirSync(runtimeDist)) {
-            fs.copyFileSync(path.join(runtimeDist, file), path.join(distSlugDir, file));
-        }
+        copyDirRecursive(runtimeDist, distSlugDir);
         return;
     }
     // Fallback: generate stubs with both types (.d.ts) AND runtime JS (.js)

package/out/src/generator/generationHelpers.js

@@ -26,7 +26,7 @@ export function buildProfileRegistries(structureDefinitions, fhirInterfaceNames)
     for (const sd of structureDefinitions) {
         const rawInterfaceName = sd.name || sd.id || 'UnnamedInterface';
         let name = toPascalCase(rawInterfaceName);
-        if (fhirInterfaceNames.includes(name)) {
+        if (fhirInterfaceNames.includes(name) && sd.derivation !== 'specialization') {
             name = `${name}Extension`;
         }
         if (name) {

package/out/src/generator/sdProcessor.js

@@ -85,7 +85,7 @@ export async function processStructureDefinition(sd, ctx) {
     const rawInterfaceName = sd.name || sd.id || 'UnnamedInterface';
     let interfaceName = toPascalCase(rawInterfaceName);
     registerProfile(sd.url || '', interfaceName);
-    if (versionCtx().interfaceNames.includes(interfaceName)) {
+    if (versionCtx().interfaceNames.includes(interfaceName) && sd.derivation !== 'specialization') {
         logger.log(`Interface name '${interfaceName}' conflicts with FHIR base type, adding 'Extension' suffix`);
         interfaceName = `${interfaceName}Extension`;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "babelfhir-ts",
-  "version": "1.5.2",
+  "version": "1.5.3",
   "description": "BabelFHIR-TS: generate TypeScript interfaces, validators, and helper classes from FHIR R4/R4B/R5 StructureDefinitions (profiles) directly inside package archives.",
   "type": "module",
   "main": "out/src/main.js",