@outbuild-company/schedule-core 1.0.0 → 1.0.1

package/dist/index.cjs

@@ -16171,132 +16171,241 @@ var WORKING_DAY_TRUE_VALUES = /* @__PURE__ */ new Set([
   "true"
 ]);
 var DEFAULT_ACTIVITY_CRETER = "DURATION";
-var VALID_ACTIVITY_CRETER_VALUES = /* @__PURE__ */ new Set(["DURATION", "COST", "HH"]);
 var DEFAULT_CONSTRAINT_TYPE = "asap";
+var CONSTRAINT_LABEL_MAP = {
+  "AS SOON AS POSSIBLE": "asap",
+  "AS LATE AS POSSIBLE": "alap",
+  "START NO EARLIER THAN": "snet",
+  "START NO LATER THAN": "snlt",
+  "FINISH NO EARLIER THAN": "fnet",
+  "FINISH NO LATER THAN": "fnlt",
+  "MUST START ON": "mso",
+  "MUST FINISH ON": "mfo"
+};
 
-// src/boundary/backend/parse-from-backend.ts
-function parseFromBackend(input, reporter = noopReporter) {
-  const sector = parseSector(input.sector);
-  const rawCalendars = (input.calendars && input.calendars.length > 0 ? input.calendars : input.sector.calendars) ?? [];
-  const calendars = rawCalendars.map(parseCalendar);
-  const calendarIds = new Set(calendars.map((c) => c.id));
-  const defaultCalendarId = pickDefaultCalendarId(calendars);
-  const baseCalendars = (input.baseCalendars ?? []).map(parseBaseCalendar);
-  const activities = input.activities.map((a) => {
-    const parsed2 = parseActivity(a, calendarIds, defaultCalendarId, reporter);
-    parsed2.for_disable_milestone_duration = Math.round(
-      Number(parsed2.duration) * sector.hoursPerDay
+// src/boundary/backend/normalize-activity.ts
+function normalizeActivities(rawActivities, context) {
+  const activities = rawActivities.map((raw) => parseActivity(raw, context));
+  forceRootProjectToRoot(activities);
+  const activityIds = new Set(activities.map((activity) => activity.id));
+  reparentOrphansToRoot(activities, activityIds, context.reporter);
+  return { activities, activityIds };
+}
+function proplannerIdField(raw) {
+  return typeof raw.id === "number" ? { proplannerId: raw.id } : {};
+}
+function isAutoSchedulable(progress) {
+  return progress === 0;
+}
+function parseConstraintLabel(label, reporter) {
+  if (!label) return null;
+  const normalized = CONSTRAINT_LABEL_MAP[label.toUpperCase()];
+  if (normalized === void 0) {
+    reporter.warn(
+      `[parseFromBackend] unknown constraint label "${label}" \u2014 defaulting to "asap"`
     );
-    return parsed2;
-  });
-  const rootProject = activities.find(
-    (a) => a.correlative_id === 0 && a.type === "project"
-  );
-  if (rootProject) rootProject.parent = ROOT_PARENT_ID;
-  const activityIds = new Set(activities.map((a) => a.id));
-  reparentOrphansToRoot(activities, activityIds, reporter);
-  const links = parseLinksDroppingDanglingReferences(
-    input.links,
-    activityIds,
-    sector.hoursPerDay,
-    reporter
-  );
-  return { sector, activities, links, calendars, baseCalendars };
+    return DEFAULT_CONSTRAINT_TYPE;
+  }
+  return normalized;
 }
-function parseBaseCalendar(raw) {
-  const r = raw;
-  const reshaped = {
-    ...raw,
-    exceptiondays: r.baseexceptiondays ?? raw.exceptiondays ?? [],
-    id: `${raw.id}-base`,
-    baseDefault: Boolean(raw.is_default),
-    is_default: false
+function resolveConstraint(raw, reporter) {
+  const constraintType = parseConstraintLabel(raw.constraint, reporter);
+  const constraintTakesDate = constraintType !== "asap" && constraintType !== "alap";
+  const constraintDate = constraintTakesDate && raw.constraint_date ? parseBackendDate(raw.constraint_date) : null;
+  return { constraint_type: constraintType, constraint_date: constraintDate };
+}
+function resolveDatesAndDuration(raw) {
+  const startDate = parseBackendDate(raw.start_date);
+  const isMilestone = raw.type === "milestone";
+  return {
+    start_date: startDate,
+    end_date: isMilestone ? startDate : parseBackendDate(raw.end_date),
+    duration: isMilestone ? 0 : Number(raw.duration)
   };
-  return parseCalendar(reshaped);
 }
-function pickDefaultCalendarId(calendars) {
-  const flaggedDefault = calendars.find((cal) => cal.is_default);
-  if (flaggedDefault) return flaggedDefault.id;
-  const firstCalendar = calendars[0];
-  if (firstCalendar) return firstCalendar.id;
-  return null;
+function buildLoadTimeBaselines(raw) {
+  const isMilestone = raw.type === "milestone";
+  return {
+    old_progress_registered: Number(raw.progress),
+    old_duration_registered: isMilestone ? 0 : Number(raw.duration),
+    old_cost_registered: Number(raw.cost),
+    old_used_cost_registered: Number(raw.used_cost ?? 0),
+    old_real_cost_registered: Number(raw.real_cost ?? 0),
+    old_hhWorkTime_registered: Number(raw.hhWorkTime)
+  };
 }
 function resolveCalendarId(rawCalendarId, knownCalendarIds, defaultCalendarId) {
   if (rawCalendarId == null) return defaultCalendarId;
   const coerced = String(rawCalendarId);
   return knownCalendarIds.has(coerced) ? coerced : defaultCalendarId;
 }
-function parseLinksDroppingDanglingReferences(backendLinks, knownActivityIds, hoursPerDay, reporter) {
-  const parsedLinks = [];
-  for (const backendLink of backendLinks) {
-    try {
-      parsedLinks.push(parseLink(backendLink, knownActivityIds, hoursPerDay));
-    } catch (parseError2) {
-      reporter.warn("[parseFromBackend] dropping invalid link", parseError2);
-    }
+function parseNewActivitiesArray(raw) {
+  if (raw == null || raw === "") return [];
+  if (Array.isArray(raw)) return raw.map(String);
+  if (typeof raw !== "string") return [];
+  try {
+    const parsed2 = JSON.parse(raw);
+    return Array.isArray(parsed2) ? parsed2.map(String) : [];
+  } catch {
+    return [];
   }
-  return dedupeLinksBySignature(parsedLinks);
 }
-function dedupeLinksBySignature(links) {
-  const bySignature = /* @__PURE__ */ new Map();
-  for (const link of links) {
-    const signature = `${link.source}-${link.target}-${link.type}`;
-    const existing = bySignature.get(signature);
-    if (!existing || linkIdAsNumber(link) > linkIdAsNumber(existing)) {
-      bySignature.set(signature, link);
-    }
+function hasUsableId(entry) {
+  if (typeof entry !== "object" || entry === null) return false;
+  if (!("id" in entry)) return false;
+  const value = entry.id;
+  return typeof value === "string" || typeof value === "number";
+}
+function parsePendingRequests(raw) {
+  if (!Array.isArray(raw)) return [];
+  const requests = [];
+  for (const entry of raw) {
+    if (hasUsableId(entry)) requests.push({ id: String(entry.id) });
   }
-  return [...bySignature.values()];
+  return requests;
 }
-function linkIdAsNumber(link) {
-  const n = Number(link.id);
-  return Number.isFinite(n) ? n : -Infinity;
-}
-function parseSector(s) {
-  const raw = s;
-  const customIdPrefix = typeof raw.custom_id_prefix === "string" && raw.custom_id_prefix.length > 0 ? raw.custom_id_prefix : void 0;
-  const incrementRaw = raw.custom_id_increment;
-  const customIdIncrement = typeof incrementRaw === "string" ? incrementRaw : typeof incrementRaw === "number" && Number.isFinite(incrementRaw) ? String(incrementRaw) : void 0;
+function parseActivity(raw, context) {
+  const id = String(raw.unique_id);
+  const parent = raw.parent_id === ROOT_PARENT_ID ? ROOT_PARENT_ID : String(raw.parent_id);
+  const calendarId = resolveCalendarId(
+    raw.calendarId,
+    context.knownCalendarIds,
+    context.defaultCalendarId
+  );
+  const inheritedDefaultCalendar = raw.calendarId == null || !context.knownCalendarIds.has(String(raw.calendarId));
+  const assignedDefaultCalendar = calendarId != null && inheritedDefaultCalendar;
+  const progress = Number(raw.progress);
+  const { constraint_type: constraintType, constraint_date: constraintDate } = resolveConstraint(raw, context.reporter);
+  const {
+    start_date: startDate,
+    end_date: endDate,
+    duration
+  } = resolveDatesAndDuration(raw);
   return {
-    id: String(s.id),
-    name: s.name,
-    hoursPerDay: s.hoursPerDay,
-    hoursPerWeek: s.hoursPerWeek,
-    dateFormat: s.dateFormat,
-    projectId: s.projectId,
-    companyId: s.companyId,
-    ...customIdPrefix !== void 0 ? { customIdPrefix } : {},
-    ...customIdIncrement !== void 0 ? { customIdIncrement } : {},
-    ...s.update_duration_for_primavera_for_end_date === true ? { updateDurationForPrimaveraEndDate: true } : {},
-    activityCreter: parseActivityCreter(raw.activity_creter),
-    // Not a backend field: a complete sector needs it; the client value
-    // overrides this default at init via `resolveStatusCriteria`.
-    statusCriteria: DEFAULT_STATUS_CRITERIA
+    ...proplannerIdField(raw),
+    id,
+    parent,
+    text: raw.name,
+    description: raw.description ?? "",
+    type: raw.type,
+    start_date: startDate,
+    end_date: endDate,
+    duration,
+    constraint_type: constraintType,
+    constraint_date: constraintDate,
+    auto_scheduling: isAutoSchedulable(progress),
+    calendar_id: calendarId,
+    assignedDefaultCalendar,
+    progress,
+    cost: Number(raw.cost),
+    used_cost: Number(raw.used_cost ?? 0),
+    real_cost: Number(raw.real_cost ?? 0),
+    hhWorkTime: Number(raw.hhWorkTime),
+    real_work: Number(raw.real_work ?? 0),
+    ponderator: Number(raw.ponderator),
+    correlative_id: raw.correlative_id,
+    is_lookahead: raw.isOnLookahead,
+    visible: raw.should_be_showed !== false,
+    newActivitiesArray: parseNewActivitiesArray(raw.newActivitiesArray),
+    activityModifications: raw.activitymodifications,
+    unique_correlative_id: raw.unique_correlative_id,
+    ganttId: raw.ganttId,
+    sectorId: raw.sectorId,
+    companyId: raw.companyId,
+    subcontractId: raw.subcontractId,
+    subcontract: raw.subcontract,
+    custom_id: raw.custom_id,
+    hasCustomPonderator: raw.hasCustomPonderator,
+    has_childs: raw.has_childs,
+    sumOfDurationRecursively: raw.sumOfDurationRecursively,
+    freeSlack: raw.freeSlack,
+    is_critical: raw.is_critical,
+    hasNewActivities: raw.hasNewActivities,
+    isNewActivity: raw.isNewActivity,
+    tasks: raw.tasks,
+    responsables: raw.responsables,
+    tags: raw.tags,
+    createdAt: raw.createdAt,
+    updatedAt: raw.updatedAt,
+    pendingRequests: parsePendingRequests(raw.pendingRequests),
+    for_disable_milestone_duration: Math.round(duration * context.hoursPerDay),
+    ...buildLoadTimeBaselines(raw),
+    ...raw.date_origin !== void 0 ? {
+      date_origin: raw.date_origin === null ? null : parseBackendDate(raw.date_origin)
+    } : {},
+    ...raw.baseline_points !== void 0 ? { baseline_points: raw.baseline_points } : {}
   };
 }
-function isAutoSchedulable(progress) {
-  return progress === 0;
+function forceRootProjectToRoot(activities) {
+  const rootProject = activities.find(
+    (activity) => activity.correlative_id === 0 && activity.type === "project"
+  );
+  if (rootProject) rootProject.parent = ROOT_PARENT_ID;
 }
-function parseActivityCreter(raw) {
-  if (typeof raw !== "string") return DEFAULT_ACTIVITY_CRETER;
-  const upper = raw.toUpperCase();
-  return VALID_ACTIVITY_CRETER_VALUES.has(upper) ? upper : DEFAULT_ACTIVITY_CRETER;
+function reparentOrphansToRoot(activities, ids, reporter) {
+  for (const activity of activities) {
+    if (activity.parent === ROOT_PARENT_ID) continue;
+    if (!ids.has(activity.parent)) {
+      reporter.warn(
+        `[parseFromBackend] activity "${activity.id}" references unknown parent "${activity.parent}" \u2014 re-parenting to root ('0')`
+      );
+      activity.parent = ROOT_PARENT_ID;
+    }
+  }
 }
-function parseCalendar(c) {
-  const workingMask = parseWorkingDays(c.working_days);
-  const { days, hours } = parseWorktimeDays(c, workingMask);
-  const dates = parseExceptionDays(c.exceptiondays);
+
+// src/boundary/backend/normalize-calendar.ts
+function normalizeCalendars(schedulingCalendars, sectorCalendars, rawBaseCalendars) {
+  const hasSchedulingCalendars = schedulingCalendars !== void 0 && schedulingCalendars.length > 0;
+  const source = hasSchedulingCalendars ? schedulingCalendars : sectorCalendars ?? [];
+  const calendars = source.map(parseSchedulingCalendar);
+  const baseCalendars = (rawBaseCalendars ?? []).map(parseBaseCalendar);
+  return {
+    calendars,
+    baseCalendars,
+    knownCalendarIds: new Set(calendars.map((calendar) => calendar.id)),
+    defaultCalendarId: pickDefaultCalendarId(calendars)
+  };
+}
+function pickDefaultCalendarId(calendars) {
+  const flaggedDefault = calendars.find((calendar) => calendar.is_default);
+  if (flaggedDefault) return flaggedDefault.id;
+  const firstCalendar = calendars[0];
+  if (firstCalendar) return firstCalendar.id;
+  return null;
+}
+function buildCalendar(raw, shape) {
+  const workingMask = parseWorkingDays(raw.working_days);
+  const { days, hours } = parseWorktimeDays(raw, workingMask);
+  const dates = parseExceptionDays(shape.exceptionsSource);
   const worktime = { days, hours };
   if (dates) worktime.dates = dates;
-  const rawBaseDefault = c.baseDefault;
   return {
-    id: String(c.id),
-    name: c.name,
-    is_default: Boolean(c.is_default),
-    ...typeof rawBaseDefault === "boolean" ? { baseDefault: rawBaseDefault } : {},
+    id: `${String(raw.id)}${shape.idSuffix}`,
+    name: raw.name,
+    is_default: shape.isDefault,
+    ...shape.baseDefault !== void 0 ? { baseDefault: shape.baseDefault } : {},
     worktime
   };
 }
+function parseSchedulingCalendar(raw) {
+  const rawBaseDefault = raw.baseDefault;
+  const baseDefault = typeof rawBaseDefault === "boolean" ? rawBaseDefault : void 0;
+  return buildCalendar(raw, {
+    idSuffix: "",
+    isDefault: Boolean(raw.is_default),
+    baseDefault,
+    exceptionsSource: raw.exceptiondays
+  });
+}
+function parseBaseCalendar(raw) {
+  return buildCalendar(raw, {
+    idSuffix: "-base",
+    isDefault: false,
+    baseDefault: Boolean(raw.is_default),
+    exceptionsSource: raw.baseexceptiondays ?? raw.exceptiondays
+  });
+}
 function parseExceptionDays(exceptions) {
   if (!Array.isArray(exceptions) || exceptions.length === 0) return null;
   const map = {};
@@ -16332,9 +16441,8 @@ function parseExceptionDate(raw) {
   const year = Number(match[1]);
   const month = Number(match[2]);
   const day = Number(match[3]);
-  if (!Number.isFinite(year) || !Number.isFinite(month) || !Number.isFinite(day)) {
-    return null;
-  }
+  const isValidDate4 = Number.isFinite(year) && Number.isFinite(month) && Number.isFinite(day);
+  if (!isValidDate4) return null;
   return Date.UTC(year, month - 1, day);
 }
 function exceptionToDateValue(exception) {
@@ -16346,17 +16454,18 @@ function exceptionToDateValue(exception) {
   }
   return void 0;
 }
+var TIME_OF_DAY = /^\d{1,2}:\d{2}$/;
 function extractExceptionWindows(shifts) {
   const windows = [];
   for (const shift of shifts) {
     const csvs = splitShiftString(shift?.shift_string);
     if (!csvs) continue;
-    if (!csvs.startsCsv.includes(",") && !csvs.endsCsv.includes(",")) {
+    const isCompactWindow = !csvs.startsCsv.includes(",") && !csvs.endsCsv.includes(",");
+    if (isCompactWindow) {
       const start = csvs.startsCsv.trim();
       const end = csvs.endsCsv.trim();
-      if (!isMissingValue(start) && !isMissingValue(end) && TIME_OF_DAY.test(start) && TIME_OF_DAY.test(end)) {
-        windows.push(`${start}-${end}`);
-      }
+      const isUsableWindow = !isMissingValue(start) && !isMissingValue(end) && TIME_OF_DAY.test(start) && TIME_OF_DAY.test(end);
+      if (isUsableWindow) windows.push(`${start}-${end}`);
       continue;
     }
     const perDay = shiftCsvToPerDayWindows(csvs.startsCsv, csvs.endsCsv);
@@ -16366,17 +16475,16 @@ function extractExceptionWindows(shifts) {
   windows.sort(compareWindowByStart);
   return windows;
 }
-var TIME_OF_DAY = /^\d{1,2}:\d{2}$/;
 function windowStartMinutes(window2) {
   const dash = window2.indexOf("-");
   const start = dash > 0 ? window2.slice(0, dash) : window2;
-  const [h, m] = start.split(":");
-  return (Number(h) || 0) * 60 + (Number(m) || 0);
+  const [hour, minute] = start.split(":");
+  return (Number(hour) || 0) * 60 + (Number(minute) || 0);
 }
-function compareWindowByStart(a, b) {
-  return windowStartMinutes(a) - windowStartMinutes(b);
+function compareWindowByStart(first, second) {
+  return windowStartMinutes(first) - windowStartMinutes(second);
 }
-function parseWorktimeDays(c, workingMask) {
+function parseWorktimeDays(raw, workingMask) {
   const windowsByDay = Array.from({ length: 7 }, () => []);
   const addCsvPair = (startsCsv, endsCsv) => {
     const perDay = shiftCsvToPerDayWindows(startsCsv, endsCsv);
@@ -16386,13 +16494,15 @@ function parseWorktimeDays(c, workingMask) {
       if (window2 && dayWindows) dayWindows.push(window2);
     }
   };
-  if (Array.isArray(c.shifts) && c.shifts.length > 0) {
-    for (const shift of c.shifts) {
+  const hasNestedShifts = Array.isArray(raw.shifts) && raw.shifts.length > 0;
+  const hasFlatShift = typeof raw.shift_start === "string" && typeof raw.shift_end === "string";
+  if (hasNestedShifts) {
+    for (const shift of raw.shifts) {
       const csvs = splitShiftString(shift?.shift_string);
       if (csvs) addCsvPair(csvs.startsCsv, csvs.endsCsv);
     }
-  } else if (typeof c.shift_start === "string" && typeof c.shift_end === "string") {
-    addCsvPair(c.shift_start, c.shift_end);
+  } else if (hasFlatShift) {
+    addCsvPair(raw.shift_start, raw.shift_end);
   }
   for (const dayWindows of windowsByDay) dayWindows.sort(compareWindowByStart);
   const firstWorkingWindows = windowsByDay.find(
@@ -16414,11 +16524,10 @@ function shiftCsvToPerDayWindows(startsCsv, endsCsv) {
   if (typeof startsCsv !== "string" || typeof endsCsv !== "string") {
     return empty;
   }
-  const starts = startsCsv.split(",").map((s) => s.trim());
-  const ends = endsCsv.split(",").map((s) => s.trim());
-  if (starts.length !== ends.length || starts.length === 0 || starts.length > WEEKDAYS_PER_WEEK) {
-    return empty;
-  }
+  const starts = startsCsv.split(",").map((value) => value.trim());
+  const ends = endsCsv.split(",").map((value) => value.trim());
+  const isAlignedWeek = starts.length === ends.length && starts.length > 0 && starts.length <= WEEKDAYS_PER_WEEK;
+  if (!isAlignedWeek) return empty;
   const windows = [...empty];
   for (let i = 0; i < starts.length; i += 1) {
     const start = starts[i];
@@ -16439,196 +16548,48 @@ function splitShiftString(raw) {
 }
 function parseWorkingDays(csv) {
   if (typeof csv !== "string") return [...CALENDAR_FALLBACK_WORKING_DAYS];
-  const parts = csv.split(",").map((s) => s.trim());
-  if (parts.length !== WEEKDAYS_PER_WEEK)
+  const parts = csv.split(",").map((value) => value.trim());
+  if (parts.length !== WEEKDAYS_PER_WEEK) {
     return [...CALENDAR_FALLBACK_WORKING_DAYS];
-  return parts.map((p) => WORKING_DAY_TRUE_VALUES.has(p));
+  }
+  return parts.map((part) => WORKING_DAY_TRUE_VALUES.has(part));
 }
 var MISSING_SHIFT_VALUES = /* @__PURE__ */ new Set(["false", "null"]);
 function isMissingValue(value) {
   return !value || MISSING_SHIFT_VALUES.has(value);
 }
-var ACTIVITY_PASSTHROUGH_FIELDS = /* @__PURE__ */ new Set([
-  // Ids and relations.
-  "unique_correlative_id",
-  "ganttId",
-  "sectorId",
-  "companyId",
-  "subcontractId",
-  "subcontract",
-  "custom_id",
-  // Computed flags / metrics from the backend.
-  "hasCustomPonderator",
-  "has_childs",
-  "sumOfDurationRecursively",
-  "freeSlack",
-  "is_critical",
-  "hasNewActivities",
-  "isNewActivity",
-  // Live validation field read by endDatePipeline; explicit so it survives by design.
-  "date_origin",
-  "baseline_points",
-  // Relation arrays.
-  "tasks",
-  "responsables",
-  "tags",
-  // `pendingRequests` is NOT passthrough — parsed explicitly below to the
-  // typed `{ id: string }[]` shape (SIR freeze authority, A1).
-  // Timestamps.
-  "createdAt",
-  "updatedAt"
-]);
-function proplannerIdField(a) {
-  return typeof a.id === "number" ? { proplannerId: a.id } : {};
-}
-function collectPassthrough(a) {
-  const passthrough = {};
-  for (const key of ACTIVITY_PASSTHROUGH_FIELDS) {
-    if (key in a) {
-      passthrough[key] = a[key];
-    }
-  }
-  return passthrough;
-}
-function resolveConstraint(a, reporter) {
-  const constraintType = parseConstraintLabel(a.constraint, reporter);
-  const constraintTakesDate = constraintType !== "asap" && constraintType !== "alap";
-  const constraintDate = constraintTakesDate && a.constraint_date ? parseBackendDate(a.constraint_date) : null;
-  return { constraint_type: constraintType, constraint_date: constraintDate };
-}
-function resolveDatesAndDuration(a) {
-  const startDate = parseBackendDate(a.start_date);
-  const isMilestone = a.type === "milestone";
-  return {
-    start_date: startDate,
-    end_date: isMilestone ? startDate : parseBackendDate(a.end_date),
-    duration: isMilestone ? 0 : Number(a.duration)
-  };
-}
-function buildLoadTimeBaselines(a) {
-  const isMilestone = a.type === "milestone";
-  return {
-    old_progress_registered: Number(a.progress),
-    old_duration_registered: isMilestone ? 0 : Number(a.duration),
-    old_cost_registered: Number(a.cost),
-    old_used_cost_registered: Number(a.used_cost ?? 0),
-    old_real_cost_registered: Number(a.real_cost ?? 0),
-    old_hhWorkTime_registered: Number(a.hhWorkTime)
-  };
-}
-function parseActivity(a, calendarIds, defaultCalendarId, reporter) {
-  const id = String(a.unique_id);
-  const parent = a.parent_id === ROOT_PARENT_ID ? ROOT_PARENT_ID : String(a.parent_id);
-  const calendarId = resolveCalendarId(
-    a.calendarId,
-    calendarIds,
-    defaultCalendarId
-  );
-  const assignedDefaultCalendar = calendarId != null && (a.calendarId == null || !calendarIds.has(String(a.calendarId)));
-  const progress = Number(a.progress);
-  const autoScheduling = isAutoSchedulable(progress);
-  const { constraint_type: constraintType, constraint_date: constraintDate } = resolveConstraint(a, reporter);
-  const {
-    start_date: startDate,
-    end_date: endDate,
-    duration
-  } = resolveDatesAndDuration(a);
-  return {
-    ...collectPassthrough(a),
-    ...proplannerIdField(a),
-    id,
-    parent,
-    text: a.name,
-    description: a.description ?? "",
-    type: a.type,
-    start_date: startDate,
-    end_date: endDate,
-    duration,
-    constraint_type: constraintType,
-    constraint_date: constraintDate,
-    progress,
-    cost: Number(a.cost),
-    used_cost: Number(a.used_cost ?? 0),
-    real_cost: Number(a.real_cost ?? 0),
-    hhWorkTime: Number(a.hhWorkTime),
-    real_work: Number(a.real_work ?? 0),
-    ponderator: Number(a.ponderator),
-    calendar_id: calendarId,
-    assignedDefaultCalendar,
-    auto_scheduling: autoScheduling,
-    correlative_id: a.correlative_id,
-    is_lookahead: a.isOnLookahead,
-    // View-model visibility bit: only an explicit backend `false` hides.
-    visible: a.should_be_showed !== false,
-    ...buildLoadTimeBaselines(a),
-    pendingRequests: parsePendingRequests(a.pendingRequests),
-    activityModifications: a.activitymodifications,
-    // D5 fix (2026-05-19): backend serializes newActivitiesArray as a
-    // JSON-encoded string; the in-memory form must be a real array so dispatch
-    // pipelines can iterate/mutate it. See DIVERGENCES_activity_create.md D5.
-    newActivitiesArray: parseNewActivitiesArray(a.newActivitiesArray)
-    // Cast: TS can't statically verify the `...collectPassthrough` spread
-    // provides every required Activity field (the loop iterates a runtime Set,
-    // not a typed contract). When the BE responds normally every passthrough
-    // field is present; a missing field is a real data bug to surface at the
-    // source, not mask via optional typing. `ActivityRuntime`
-    // (= Activity & DhtmlxHeritageFields) because the literal includes the
-    // old_*_registered baselines (DHTMLX heritage — G1); it is assignable to
-    // Activity.
-  };
-}
-function parseNewActivitiesArray(raw) {
-  if (raw == null || raw === "") return [];
-  if (Array.isArray(raw)) return raw.map(String);
-  if (typeof raw !== "string") return [];
-  try {
-    const parsed2 = JSON.parse(raw);
-    return Array.isArray(parsed2) ? parsed2.map(String) : [];
-  } catch {
-    return [];
-  }
-}
-function parsePendingRequests(raw) {
-  if (!Array.isArray(raw)) return [];
-  return raw.filter((r) => r != null && typeof r === "object").map((r) => ({ id: String(r.id) }));
+
+// src/boundary/backend/normalize-link.ts
+function isLinkTypeCode(value) {
+  return value === "0" || value === "1" || value === "2" || value === "3";
 }
-var CONSTRAINT_LABEL_MAP = {
-  "AS SOON AS POSSIBLE": "asap",
-  "AS LATE AS POSSIBLE": "alap",
-  "START NO EARLIER THAN": "snet",
-  "START NO LATER THAN": "snlt",
-  "FINISH NO EARLIER THAN": "fnet",
-  "FINISH NO LATER THAN": "fnlt",
-  "MUST START ON": "mso",
-  "MUST FINISH ON": "mfo"
-};
-function parseConstraintLabel(label, reporter) {
-  if (!label) return null;
-  const normalized = CONSTRAINT_LABEL_MAP[label.toUpperCase()];
-  if (normalized === void 0) {
-    reporter.warn(
-      `[parseFromBackend] unknown constraint label "${label}" \u2014 defaulting to "asap"`
-    );
-    return DEFAULT_CONSTRAINT_TYPE;
-  }
-  return normalized;
+function resolveLinkType(rawType) {
+  if (typeof rawType !== "string") return null;
+  const fromLabel = parseLinkTypeCode(rawType);
+  if (fromLabel) return fromLabel;
+  if (isLinkTypeCode(rawType)) return rawType;
+  return null;
 }
-function reparentOrphansToRoot(activities, ids, reporter) {
-  for (const activity of activities) {
-    if (activity.parent === ROOT_PARENT_ID) continue;
-    if (!ids.has(activity.parent)) {
-      reporter.warn(
-        `[parseFromBackend] activity "${activity.id}" references unknown parent "${activity.parent}" \u2014 re-parenting to root ('0')`
+function normalizeLinks(rawLinks, context) {
+  const parsedLinks = [];
+  for (const rawLink of rawLinks) {
+    try {
+      parsedLinks.push(
+        parseLink(rawLink, context.knownActivityIds, context.hoursPerDay)
+      );
+    } catch (parseError2) {
+      context.reporter.warn(
+        "[parseFromBackend] dropping invalid link",
+        parseError2
       );
-      activity.parent = ROOT_PARENT_ID;
     }
   }
+  return dedupeLinksBySignature(parsedLinks);
 }
-function parseLink(l, activityIds, hoursPerDay) {
-  const lr = l;
-  const id = String(lr.unique_id ?? lr.id);
-  const source = String(lr.source_id ?? lr.source ?? "");
-  const target = String(lr.target_id ?? lr.target ?? "");
+function parseLink(link, activityIds, hoursPerDay) {
+  const id = String(link.unique_id ?? link.id);
+  const source = String(link.source_id ?? link.source ?? "");
+  const target = String(link.target_id ?? link.target ?? "");
   if (!activityIds.has(source)) {
     throw new Error(
       `[parseFromBackend] link "${id}" source "${source}" does not exist`
@@ -16639,24 +16600,108 @@ function parseLink(l, activityIds, hoursPerDay) {
       `[parseFromBackend] link "${id}" target "${target}" does not exist`
     );
   }
-  const rawType = String(lr.type ?? "fs");
-  const type = parseLinkTypeCode(rawType) ?? rawType;
-  const ganttIdRaw = lr.ganttId;
-  const sectorIdRaw = lr.sectorId;
-  const proplannerIdRaw = lr.id;
+  const type = resolveLinkType(link.type);
+  if (type === null) {
+    throw new Error(
+      `[parseFromBackend] link "${id}" has invalid type "${String(link.type)}"`
+    );
+  }
+  const ganttIdRaw = link.ganttId;
+  const sectorIdRaw = link.sectorId;
+  const proplannerIdRaw = link.id;
   return {
     id,
     source,
     target,
     type,
-    // Backend ships `lag` in DAYS; the core stores it internally in WORKING
-    // HOURS (mirrors `duration`). Convert here — the single backend boundary.
-    lag: lagDaysToHours(Number(lr.lag ?? 0), hoursPerDay),
+    lag: lagDaysToHours(Number(link.lag ?? 0), hoursPerDay),
     ...typeof ganttIdRaw === "number" ? { ganttId: ganttIdRaw } : {},
     ...typeof sectorIdRaw === "number" ? { sectorId: sectorIdRaw } : {},
     ...typeof proplannerIdRaw === "number" ? { proplannerId: proplannerIdRaw } : {}
   };
 }
+function dedupeLinksBySignature(links) {
+  const bySignature = /* @__PURE__ */ new Map();
+  for (const link of links) {
+    const signature = `${link.source}-${link.target}-${link.type}`;
+    const existing = bySignature.get(signature);
+    if (!existing || linkIdAsNumber(link) > linkIdAsNumber(existing)) {
+      bySignature.set(signature, link);
+    }
+  }
+  return [...bySignature.values()];
+}
+function linkIdAsNumber(link) {
+  const numeric = Number(link.id);
+  return Number.isFinite(numeric) ? numeric : -Infinity;
+}
+
+// src/boundary/backend/normalize-sector.ts
+function parseActivityCreter(raw) {
+  if (typeof raw !== "string") return DEFAULT_ACTIVITY_CRETER;
+  switch (raw.toUpperCase()) {
+    case "DURATION":
+      return "DURATION";
+    case "COST":
+      return "COST";
+    case "HH":
+      return "HH";
+    default:
+      return DEFAULT_ACTIVITY_CRETER;
+  }
+}
+function readCustomIdPrefix(sector) {
+  const prefix = sector.custom_id_prefix;
+  const hasPrefix = typeof prefix === "string" && prefix.length > 0;
+  return hasPrefix ? prefix : void 0;
+}
+function readCustomIdIncrement(sector) {
+  const increment = sector.custom_id_increment;
+  if (typeof increment === "string") return increment;
+  const isFiniteNumber = typeof increment === "number" && Number.isFinite(increment);
+  return isFiniteNumber ? String(increment) : void 0;
+}
+function parseSector(sector) {
+  const customIdPrefix = readCustomIdPrefix(sector);
+  const customIdIncrement = readCustomIdIncrement(sector);
+  const isPrimaveraEndDate = sector.update_duration_for_primavera_for_end_date === true;
+  return {
+    id: String(sector.id),
+    name: sector.name,
+    hoursPerDay: sector.hoursPerDay,
+    hoursPerWeek: sector.hoursPerWeek,
+    dateFormat: sector.dateFormat,
+    projectId: sector.projectId,
+    companyId: sector.companyId,
+    ...customIdPrefix !== void 0 ? { customIdPrefix } : {},
+    ...customIdIncrement !== void 0 ? { customIdIncrement } : {},
+    ...isPrimaveraEndDate ? { updateDurationForPrimaveraEndDate: true } : {},
+    activityCreter: parseActivityCreter(sector.activity_creter),
+    statusCriteria: DEFAULT_STATUS_CRITERIA
+  };
+}
+
+// src/boundary/backend/parse-from-backend.ts
+function parseFromBackend(input, reporter = noopReporter) {
+  const sector = parseSector(input.sector);
+  const { calendars, baseCalendars, knownCalendarIds, defaultCalendarId } = normalizeCalendars(
+    input.calendars,
+    input.sector.calendars,
+    input.baseCalendars
+  );
+  const { activities, activityIds } = normalizeActivities(input.activities, {
+    knownCalendarIds,
+    defaultCalendarId,
+    hoursPerDay: sector.hoursPerDay,
+    reporter
+  });
+  const links = normalizeLinks(input.links, {
+    knownActivityIds: activityIds,
+    hoursPerDay: sector.hoursPerDay,
+    reporter
+  });
+  return { sector, activities, links, calendars, baseCalendars };
+}
 
 // src/generators/activity-id-generator.ts
 function createActivityIdGenerator(options = {}) {