@claritylabs/cl-sdk 3.1.4 → 3.1.5

package/dist/index.mjs

@@ -80,53 +80,70 @@ function sanitizeNulls(obj) {
 
 // src/core/strict-schema.ts
 import { z } from "zod";
+function schemaDef(schema) {
+  return schema._zod?.def ?? schema._def ?? {};
+}
+function schemaKind(schema) {
+  const def = schemaDef(schema);
+  const raw = typeof def.type === "string" ? def.type : typeof def.typeName === "string" ? def.typeName : typeof schema.type === "string" ? schema.type : void 0;
+  return raw?.replace(/^Zod/, "").toLowerCase();
+}
+function schemaDescription(schema) {
+  const def = schemaDef(schema);
+  return schema.description ?? def.description;
+}
+function objectShape(schema) {
+  const def = schemaDef(schema);
+  const shape = schema.shape ?? def.shape;
+  return typeof shape === "function" ? shape() : shape;
+}
+function withDescription(schema, description) {
+  return description ? schema.describe(description) : schema;
+}
 function toStrictSchema(schema) {
-  const def = schema._zod?.def;
-  const typeName = def?.type ?? schema.type;
-  if (typeName === "object") {
-    const shape = schema.shape;
+  const kind = schemaKind(schema);
+  const def = schemaDef(schema);
+  if (kind === "object") {
+    const shape = objectShape(schema);
     if (!shape) return schema;
     const newShape = {};
     for (const [key, value] of Object.entries(shape)) {
       const field = value;
-      const fieldDef = field._zod?.def;
-      const fieldType = fieldDef?.type ?? field.type;
-      if (fieldType === "optional") {
+      const fieldDef = schemaDef(field);
+      const fieldKind = schemaKind(field);
+      if (fieldKind === "optional") {
         const innerType = fieldDef?.innerType;
-        const description = field.description ?? fieldDef?.description ?? field._zod?.def?.description;
+        const description = schemaDescription(field);
         if (innerType) {
           const transformed = toStrictSchema(innerType);
-          let nullable = z.nullable(transformed);
-          if (description) nullable = nullable.describe(description);
-          newShape[key] = nullable;
+          newShape[key] = withDescription(z.nullable(transformed), description);
         } else {
-          let nullable = z.nullable(field);
-          if (description) nullable = nullable.describe(description);
-          newShape[key] = nullable;
+          newShape[key] = withDescription(z.nullable(field), description);
         }
       } else {
         newShape[key] = toStrictSchema(field);
       }
     }
-    const objDesc = schema.description ?? def?.description ?? schema._zod?.def?.description;
-    const result = z.object(newShape);
-    return objDesc ? result.describe(objDesc) : result;
+    return withDescription(z.object(newShape), schemaDescription(schema));
   }
-  if (typeName === "array") {
-    const element = def?.element ?? schema.element;
+  if (kind === "array") {
+    const element = def.element ?? def.type ?? schema.element;
     if (element) {
-      const arrDesc = schema.description ?? def?.description ?? schema._zod?.def?.description;
-      const result = z.array(toStrictSchema(element));
-      return arrDesc ? result.describe(arrDesc) : result;
+      return withDescription(z.array(toStrictSchema(element)), schemaDescription(schema));
     }
     return schema;
   }
-  if (typeName === "nullable") {
+  if (kind === "nullable") {
     const innerType = def?.innerType;
     if (innerType) {
-      const nullDesc = schema.description ?? def?.description ?? schema._zod?.def?.description;
-      const result = z.nullable(toStrictSchema(innerType));
-      return nullDesc ? result.describe(nullDesc) : result;
+      return withDescription(z.nullable(toStrictSchema(innerType)), schemaDescription(schema));
+    }
+    return schema;
+  }
+  if (kind === "default") {
+    const innerType = def?.innerType;
+    if (innerType) {
+      return withDescription(z.nullable(toStrictSchema(innerType)), schemaDescription(schema));
     }
     return schema;
   }
@@ -9849,6 +9866,8 @@ Rules:
 - Keep a coverage when it is a real operational coverage/benefit even if only one term needs cleanup.
 - When changing a term's semantic meaning, set kind to the corrected normalized term kind.
 - Do not add new coverage rows or new terms; this pass cleans the existing projection.
+- Include every JSON key in each decision. Use null for scalar fields you are not changing and [] for source ID lists you are not changing.
+- For each coverage decision, always include termDecisions. Use [] when no terms need cleanup.
 - Keep reasons concise and factual.
 
 Candidate projection:
@@ -9859,9 +9878,6 @@ ${JSON.stringify(nodes, null, 2)}
 
 Return JSON with coverageDecisions and warnings only.`;
 }
-function hasOwn(object, key) {
-  return Object.prototype.hasOwnProperty.call(object, key);
-}
 function uniqueStrings(values) {
   return [...new Set(values.filter((value) => value.length > 0))];
 }
@@ -9936,18 +9952,16 @@ function applyTermCleanupDecision(term, decision, validNodeIds, validSpanIds) {
     sourceSpanIds: cleanupIds(decision.sourceSpanIds, validSpanIds, term.sourceSpanIds)
   };
   if (next.sourceNodeIds.length === 0 && next.sourceSpanIds.length === 0) return term;
-  if (hasOwn(decision, "amount")) {
-    if (typeof decision.amount === "number" && Number.isFinite(decision.amount)) next.amount = decision.amount;
-    else delete next.amount;
+  if (typeof decision.amount === "number" && Number.isFinite(decision.amount)) {
+    next.amount = decision.amount;
   } else if (decision.value || decision.kind) {
     const amount = next.kind === "retroactive_date" ? void 0 : amountFromOperationalValue(next.value);
     if (amount === void 0) delete next.amount;
     else next.amount = amount;
   }
-  if (hasOwn(decision, "appliesTo")) {
+  if (decision.appliesTo != null) {
     const appliesTo = cleanProfileValue(decision.appliesTo);
     if (appliesTo) next.appliesTo = appliesTo;
-    else delete next.appliesTo;
   }
   return next;
 }
@@ -9966,46 +9980,42 @@ function applyCoverageCleanupDecision(coverage, decision, validNodeIds, validSpa
   const name = cleanProfileValue(decision.name);
   if (name) next.name = name;
   if (decision.coverageOrigin) next.coverageOrigin = decision.coverageOrigin;
-  if (hasOwn(decision, "limit")) {
+  if (decision.limit != null) {
     const value = cleanProfileValue(decision.limit);
     if (value) next.limit = value;
-    else delete next.limit;
   }
-  if (hasOwn(decision, "deductible")) {
+  if (decision.deductible != null) {
     const value = cleanProfileValue(decision.deductible);
     if (value) next.deductible = value;
-    else delete next.deductible;
   }
-  if (hasOwn(decision, "premium")) {
+  if (decision.premium != null) {
     const value = cleanProfileValue(decision.premium);
     if (value) next.premium = value;
-    else delete next.premium;
   }
-  if (hasOwn(decision, "retroactiveDate")) {
+  if (decision.retroactiveDate != null) {
     const value = cleanProfileValue(decision.retroactiveDate);
     if (value) next.retroactiveDate = value;
-    else delete next.retroactiveDate;
   }
   const termDecisions = (decision.termDecisions ?? []).filter((termDecision) => termDecision.termIndex < coverage.limits.length);
   const termDecisionByIndex = new Map(termDecisions.map((termDecision) => [termDecision.termIndex, termDecision]));
   next.limits = coverage.limits.map((term, index) => applyTermCleanupDecision(term, termDecisionByIndex.get(index), validNodeIds, validSpanIds)).filter((term) => Boolean(term));
   if (termDecisions.length > 0) {
-    if (!hasOwn(decision, "limit") && termDecisionsTouch(coverage, termDecisions, isLimitTerm)) {
+    if (decision.limit == null && termDecisionsTouch(coverage, termDecisions, isLimitTerm)) {
       const value = primaryLimitFromTerms(next.limits);
       if (value) next.limit = value;
       else delete next.limit;
     }
-    if (!hasOwn(decision, "deductible") && termDecisionsTouch(coverage, termDecisions, isDeductibleTerm)) {
+    if (decision.deductible == null && termDecisionsTouch(coverage, termDecisions, isDeductibleTerm)) {
       const value = deductibleFromTerms(next.limits);
       if (value) next.deductible = value;
       else delete next.deductible;
     }
-    if (!hasOwn(decision, "premium") && termDecisionsTouch(coverage, termDecisions, isPremiumTerm)) {
+    if (decision.premium == null && termDecisionsTouch(coverage, termDecisions, isPremiumTerm)) {
       const value = premiumFromTerms(next.limits);
       if (value) next.premium = value;
       else delete next.premium;
     }
-    if (!hasOwn(decision, "retroactiveDate") && termDecisionsTouch(coverage, termDecisions, isRetroactiveDateTerm)) {
+    if (decision.retroactiveDate == null && termDecisionsTouch(coverage, termDecisions, isRetroactiveDateTerm)) {
       const value = retroactiveDateFromTerms(next.limits);
       if (value) next.retroactiveDate = value;
       else delete next.retroactiveDate;