@acorex-platform/module-workplacesafety-management-client 0.0.21

package/fesm2022/acorex-platform-module-workplacesafety-management-client-contracts.mjs

@@ -0,0 +1,1646 @@
+//#region ----   GHS symbol options   ----
+/** Asset base path for GHS pictograms (served from demo app assets). */
+const GHS_IMAGE_BASE = '/assets/workplacesafety-management/ghs';
+const WORKPLACE_SAFETY_GHS_SYMBOL_OPTIONS = [
+    {
+        id: 'GHS01',
+        title: 'GHS01 — Exploding bomb',
+        description: 'Explosion, blast or projection hazard.',
+        imageUrl: `${GHS_IMAGE_BASE}/explos.gif`,
+    },
+    {
+        id: 'GHS02',
+        title: 'GHS02 — Flame',
+        description: 'Flammable liquids, solids and gases; including self-reactive substances.',
+        imageUrl: `${GHS_IMAGE_BASE}/flamme.gif`,
+    },
+    {
+        id: 'GHS03',
+        title: 'GHS03 — Flame over circle',
+        description: 'Oxidising liquids, solids and gases; may cause or intensify fire.',
+        imageUrl: `${GHS_IMAGE_BASE}/rondflam.gif`,
+    },
+    {
+        id: 'GHS04',
+        title: 'GHS04 — Gas cylinder',
+        description: 'Gases under pressure.',
+        imageUrl: `${GHS_IMAGE_BASE}/bottle.gif`,
+    },
+    {
+        id: 'GHS05',
+        title: 'GHS05 — Skull and crossbones',
+        description: 'Fatal or toxic if swallowed, inhaled or in contact with skin.',
+        imageUrl: `${GHS_IMAGE_BASE}/skull.gif`,
+    },
+    {
+        id: 'GHS06',
+        title: 'GHS06 — Exclamation mark',
+        description: 'Low level toxicity; irritant or harmful to health.',
+        imageUrl: `${GHS_IMAGE_BASE}/exclam.gif`,
+    },
+    {
+        id: 'GHS07',
+        title: 'GHS07 — Corrosion',
+        description: 'Corrosive chemicals; may cause severe skin and eye damage.',
+        imageUrl: `${GHS_IMAGE_BASE}/acid_red.gif`,
+    },
+    {
+        id: 'GHS08',
+        title: 'GHS08 — Health hazard',
+        description: 'Chronic health hazards; carcinogenicity, mutagenicity, reproductive toxicity.',
+        imageUrl: `${GHS_IMAGE_BASE}/silhouete.gif`,
+    },
+    {
+        id: 'GHS09',
+        title: 'GHS09 — Environment',
+        description: 'Hazardous to aquatic life and the environment.',
+        imageUrl: `${GHS_IMAGE_BASE}/Aquatic-pollut-red.gif`,
+    },
+];
+//#endregion
+
+/**
+ * Safety & Risk capabilities used by this module.
+ * Domain capability keys for this module. Root groups live in `AXPCommonPermissionGroupKeys` (common contracts).
+ */
+const AXPSafetyRiskPermissionKeys = {
+    Access: 'SafetyRisk:Permission:Access',
+    MaintainSafety: 'SafetyRisk:Permission:MaintainSafety',
+    MaintainRisk: 'SafetyRisk:Permission:MaintainRisk',
+    MaintainHealth: 'SafetyRisk:Permission:MaintainHealth',
+    MaintainAssessments: 'SafetyRisk:Permission:MaintainAssessments',
+    Setup: 'SafetyRisk:Permission:Setup',
+};
+/**
+ * @deprecated Prefer {@link AXPSafetyRiskPermissionKeys}.
+ * Legacy nested shape kept so existing imports compile during migration.
+ */
+const AXMWorkplaceSafetyManagementPermissionKeys = {
+    WorkplaceSafetyManagement: {
+        Management: AXPSafetyRiskPermissionKeys.Access,
+        Hazard: {
+            Management: AXPSafetyRiskPermissionKeys.MaintainSafety,
+            View: AXPSafetyRiskPermissionKeys.MaintainSafety,
+            Create: AXPSafetyRiskPermissionKeys.MaintainSafety,
+            Update: AXPSafetyRiskPermissionKeys.MaintainSafety,
+            Delete: AXPSafetyRiskPermissionKeys.MaintainSafety,
+        },
+        HazardRegister: {
+            Management: AXPSafetyRiskPermissionKeys.MaintainSafety,
+            View: AXPSafetyRiskPermissionKeys.MaintainSafety,
+            Create: AXPSafetyRiskPermissionKeys.MaintainSafety,
+            Update: AXPSafetyRiskPermissionKeys.MaintainSafety,
+            Delete: AXPSafetyRiskPermissionKeys.MaintainSafety,
+        },
+        PpeItem: {
+            Management: AXPSafetyRiskPermissionKeys.MaintainSafety,
+            View: AXPSafetyRiskPermissionKeys.MaintainSafety,
+            Create: AXPSafetyRiskPermissionKeys.MaintainSafety,
+            Update: AXPSafetyRiskPermissionKeys.MaintainSafety,
+            Delete: AXPSafetyRiskPermissionKeys.MaintainSafety,
+        },
+        HazardPpeRule: {
+            Management: AXPSafetyRiskPermissionKeys.MaintainSafety,
+            View: AXPSafetyRiskPermissionKeys.MaintainSafety,
+            Create: AXPSafetyRiskPermissionKeys.MaintainSafety,
+            Update: AXPSafetyRiskPermissionKeys.MaintainSafety,
+            Delete: AXPSafetyRiskPermissionKeys.MaintainSafety,
+        },
+        HazardRisk: {
+            Management: AXPSafetyRiskPermissionKeys.MaintainSafety,
+            View: AXPSafetyRiskPermissionKeys.MaintainSafety,
+            Create: AXPSafetyRiskPermissionKeys.MaintainSafety,
+            Update: AXPSafetyRiskPermissionKeys.MaintainSafety,
+            Delete: AXPSafetyRiskPermissionKeys.MaintainSafety,
+        },
+        HazardRiskPpeRule: {
+            Management: AXPSafetyRiskPermissionKeys.MaintainSafety,
+            View: AXPSafetyRiskPermissionKeys.MaintainSafety,
+            Create: AXPSafetyRiskPermissionKeys.MaintainSafety,
+            Update: AXPSafetyRiskPermissionKeys.MaintainSafety,
+            Delete: AXPSafetyRiskPermissionKeys.MaintainSafety,
+        },
+        ControlHierarchyLevels: {
+            Management: AXPSafetyRiskPermissionKeys.Setup,
+        },
+        ControlMeasure: {
+            Management: AXPSafetyRiskPermissionKeys.MaintainSafety,
+            View: AXPSafetyRiskPermissionKeys.MaintainSafety,
+            Create: AXPSafetyRiskPermissionKeys.MaintainSafety,
+            Update: AXPSafetyRiskPermissionKeys.MaintainSafety,
+            Delete: AXPSafetyRiskPermissionKeys.MaintainSafety,
+        },
+        SafetyPlan: {
+            Management: AXPSafetyRiskPermissionKeys.MaintainSafety,
+            View: AXPSafetyRiskPermissionKeys.MaintainSafety,
+            Create: AXPSafetyRiskPermissionKeys.MaintainSafety,
+            Update: AXPSafetyRiskPermissionKeys.MaintainSafety,
+            Delete: AXPSafetyRiskPermissionKeys.MaintainSafety,
+        },
+        SafetyPlanType: {
+            Management: 'WorkplaceSafetyManagement:Permission:SafetyPlanType.Management',
+            View: 'WorkplaceSafetyManagement:Permission:SafetyPlanType.View',
+            Create: 'WorkplaceSafetyManagement:Permission:SafetyPlanType.Create',
+            Update: 'WorkplaceSafetyManagement:Permission:SafetyPlanType.Update',
+            Delete: 'WorkplaceSafetyManagement:Permission:SafetyPlanType.Delete',
+        },
+        SafetyPlanTypeSection: {
+            Management: 'WorkplaceSafetyManagement:Permission:SafetyPlanTypeSection.Management',
+            View: 'WorkplaceSafetyManagement:Permission:SafetyPlanTypeSection.View',
+            Create: 'WorkplaceSafetyManagement:Permission:SafetyPlanTypeSection.Create',
+            Update: 'WorkplaceSafetyManagement:Permission:SafetyPlanTypeSection.Update',
+            Delete: 'WorkplaceSafetyManagement:Permission:SafetyPlanTypeSection.Delete',
+        },
+        SectionType: {
+            Management: AXPSafetyRiskPermissionKeys.Setup,
+            View: AXPSafetyRiskPermissionKeys.Setup,
+            Create: AXPSafetyRiskPermissionKeys.Setup,
+            Update: AXPSafetyRiskPermissionKeys.Setup,
+            Delete: AXPSafetyRiskPermissionKeys.Setup,
+        },
+        SafetyPlanSection: {
+            Management: AXPSafetyRiskPermissionKeys.MaintainSafety,
+            View: AXPSafetyRiskPermissionKeys.MaintainSafety,
+            Create: AXPSafetyRiskPermissionKeys.MaintainSafety,
+            Update: AXPSafetyRiskPermissionKeys.MaintainSafety,
+            Delete: AXPSafetyRiskPermissionKeys.MaintainSafety,
+        },
+    },
+};
+
+//#region ---- Command keys ----
+const AXMWorkplaceSafetyManagementCommandKeys = {
+    SafetyPlan: {
+        Publish: 'WorkplaceSafetyManagement.SafetyPlan:Publish',
+        ChangeType: 'WorkplaceSafetyManagement.SafetyPlan:ChangeType',
+    },
+};
+//#endregion
+
+//#region ----   Menu keys   ----
+const AXMWorkplaceSafetyManagementMenuKeys = {
+    Root: 'WorkplaceSafetyManagement:Menu',
+    SafetyPlans: 'WorkplaceSafetyManagement:Menu:SafetyPlans',
+    SafetyPlanSections: 'WorkplaceSafetyManagement:Menu:SafetyPlanSections',
+    SectionTypes: 'WorkplaceSafetyManagement:Menu:SectionTypes',
+    WorkStepTypes: 'WorkplaceSafetyManagement:Menu:WorkStepTypes',
+    SafetyPlanTypes: 'WorkplaceSafetyManagement:Menu:SafetyPlanTypes',
+    SafetyPlanTypeSections: 'WorkplaceSafetyManagement:Menu:SafetyPlanTypeSections',
+    Configuration: 'WorkplaceSafetyManagement:Menu:Configuration',
+};
+//#endregion
+
+const config = {
+    i18n: 'workplacesafety-management',
+    module: 'WorkplaceSafetyManagement',
+};
+const RootConfig = {
+    config,
+    module: {
+        name: config.module,
+        title: `@${config.i18n}:module.title`,
+        icon: 'fa-light fa-building-shield',
+    },
+    entities: {
+        hazard: {
+            name: 'Hazard',
+            source: `${config.module}.Hazard`,
+            title: `@${config.i18n}:hazards.entities.hazard.title`,
+            titlePlural: `@${config.i18n}:hazards.entities.hazard.plural`,
+            icon: 'fa-light fa-triangle-exclamation',
+        },
+        hazardRegister: {
+            name: 'HazardRegister',
+            source: `${config.module}.HazardRegister`,
+            title: `@${config.i18n}:hazard-registers.entities.hazard-register.title`,
+            titlePlural: `@${config.i18n}:hazard-registers.entities.hazard-register.plural`,
+            icon: 'fa-light fa-clipboard-list',
+        },
+        ppeItem: {
+            name: 'PpeItem',
+            source: `${config.module}.PpeItem`,
+            title: `@${config.i18n}:ppe-items.entities.ppe-item.title`,
+            titlePlural: `@${config.i18n}:ppe-items.entities.ppe-item.plural`,
+            icon: 'fa-light fa-helmet-safety',
+        },
+        hazardPpeRule: {
+            name: 'HazardPpeRule',
+            source: `${config.module}.HazardPpeRule`,
+            title: `@${config.i18n}:hazard-ppe-rules.entities.hazard-ppe-rule.title`,
+            titlePlural: `@${config.i18n}:hazard-ppe-rules.entities.hazard-ppe-rule.plural`,
+            icon: 'fa-light fa-user-helmet-safety',
+        },
+        hazardRisk: {
+            name: 'HazardRisk',
+            source: `${config.module}.HazardRisk`,
+            title: `@${config.i18n}:hazard-risks.entities.hazard-risk.title`,
+            titlePlural: `@${config.i18n}:hazard-risks.entities.hazard-risk.plural`,
+            icon: 'fa-light fa-shield-exclamation',
+        },
+        hazardRiskPpeRule: {
+            name: 'HazardRiskPpeRule',
+            source: `${config.module}.HazardRiskPpeRule`,
+            title: `@${config.i18n}:hazard-risk-ppe-rules.entities.hazard-risk-ppe-rule.title`,
+            titlePlural: `@${config.i18n}:hazard-risk-ppe-rules.entities.hazard-risk-ppe-rule.plural`,
+            icon: 'fa-light fa-user-helmet-safety',
+        },
+        controlHierarchyLevels: {
+            name: 'ControlHierarchyLevels',
+            source: `${config.module}.ControlHierarchyLevels`,
+            title: `@${config.i18n}:control-measure-types.entities.control-measure-type.title`,
+            titlePlural: `@${config.i18n}:control-measure-types.entities.control-measure-type.plural`,
+            icon: 'fa-light fa-layer-group',
+        },
+        controlMeasure: {
+            name: 'ControlMeasure',
+            source: `${config.module}.ControlMeasure`,
+            title: `@${config.i18n}:control-measures.entities.control-measure.title`,
+            titlePlural: `@${config.i18n}:control-measures.entities.control-measure.plural`,
+            icon: 'fa-light fa-shield-check',
+        },
+        safetyPlan: {
+            name: 'SafetyPlan',
+            source: `${config.module}.SafetyPlan`,
+            title: `@${config.i18n}:safety-plans.entities.safety-plan.title`,
+            titlePlural: `@${config.i18n}:safety-plans.entities.safety-plan.plural`,
+            icon: 'fa-light fa-file-shield',
+        },
+        safetyPlanType: {
+            name: 'SafetyPlanType',
+            source: `${config.module}.SafetyPlanType`,
+            title: `@${config.i18n}:safety-plan-types.entities.safety-plan-type.title`,
+            titlePlural: `@${config.i18n}:safety-plan-types.entities.safety-plan-type.plural`,
+            icon: 'fa-light fa-file-lines',
+        },
+        safetyPlanTypeSection: {
+            name: 'SafetyPlanTypeSection',
+            source: `${config.module}.SafetyPlanTypeSection`,
+            title: `@${config.i18n}:safety-plan-type-sections.entities.safety-plan-type-section.title`,
+            titlePlural: `@${config.i18n}:safety-plan-type-sections.entities.safety-plan-type-section.plural`,
+            icon: 'fa-light fa-list-ol',
+        },
+        sectionType: {
+            name: 'SectionType',
+            source: `${config.module}.SectionType`,
+            title: `@${config.i18n}:section-types.entities.section-type.title`,
+            titlePlural: `@${config.i18n}:section-types.entities.section-type.plural`,
+            icon: 'fa-light fa-list-tree',
+        },
+        safetyTemplate: {
+            name: 'SafetyTemplate',
+            source: `${config.module}.SafetyTemplate`,
+            title: `@${config.i18n}:safety-templates.entities.safety-template.title`,
+            titlePlural: `@${config.i18n}:safety-templates.entities.safety-template.plural`,
+            icon: 'fa-light fa-file-lines',
+        },
+        safetyPlanSection: {
+            name: 'SafetyPlanSection',
+            source: `${config.module}.SafetyPlanSection`,
+            title: `@${config.i18n}:safety-plan-sections.entities.safety-plan-section.title`,
+            titlePlural: `@${config.i18n}:safety-plan-sections.entities.safety-plan-section.plural`,
+            icon: 'fa-light fa-list-ol',
+        },
+        workStepType: {
+            name: 'WorkStepType',
+            source: `${config.module}.WorkStepType`,
+            title: `@${config.i18n}:work-step-types.entities.work-step-type.title`,
+            titlePlural: `@${config.i18n}:work-step-types.entities.work-step-type.plural`,
+            icon: 'fa-light fa-list-tree',
+        },
+        safetyPlanWorkStep: {
+            name: 'SafetyPlanWorkStep',
+            source: `${config.module}.SafetyPlanWorkStep`,
+            title: `@${config.i18n}:safety-plan-work-steps.entities.safety-plan-work-step.title`,
+            titlePlural: `@${config.i18n}:safety-plan-work-steps.entities.safety-plan-work-step.plural`,
+            icon: 'fa-light fa-list-check',
+        },
+    },
+    queries: {
+        dashboard: {
+            openHazardsKpi: `${config.module}:Dashboard:OpenHazardsKpi`,
+            highRisksKpi: `${config.module}:Dashboard:HighRisksKpi`,
+            activeSafetyPlansKpi: `${config.module}:Dashboard:ActiveSafetyPlansKpi`,
+            take5ChecklistsKpi: `${config.module}:Dashboard:Take5ChecklistsKpi`,
+            take5CompletedKpi: `${config.module}:Dashboard:Take5CompletedKpi`,
+            hazardsByCategoryDonut: `${config.module}:Dashboard:HazardsByCategoryDonut`,
+            risksByRatingBar: `${config.module}:Dashboard:RisksByRatingBar`,
+            plansByTypeBar: `${config.module}:Dashboard:PlansByTypeBar`,
+            hazardsByStatusBar: `${config.module}:Dashboard:HazardsByStatusBar`,
+            ppeCoverageDonut: `${config.module}:Dashboard:PpeCoverageDonut`,
+        },
+    },
+};
+
+//#region ----   Imports   ----
+//#endregion
+//#region ----   Enums   ----
+var AXMHazardPpeRuleRequirementType;
+(function (AXMHazardPpeRuleRequirementType) {
+    AXMHazardPpeRuleRequirementType["Required"] = "required";
+    AXMHazardPpeRuleRequirementType["Recommended"] = "recommended";
+    AXMHazardPpeRuleRequirementType["Conditional"] = "conditional";
+})(AXMHazardPpeRuleRequirementType || (AXMHazardPpeRuleRequirementType = {}));
+//#endregion
+
+//#region ----   Hazard PPE rule requirement type options   ----
+const WORKPLACE_SAFETY_HAZARD_PPE_RULE_REQUIREMENT_TYPE_OPTIONS = [
+    {
+        id: AXMHazardPpeRuleRequirementType.Required,
+        title: '@workplacesafety-management:hazard-ppe-rules.entities.hazard-ppe-rule.fields.requirement-type.options.required',
+    },
+    {
+        id: AXMHazardPpeRuleRequirementType.Recommended,
+        title: '@workplacesafety-management:hazard-ppe-rules.entities.hazard-ppe-rule.fields.requirement-type.options.recommended',
+    },
+    {
+        id: AXMHazardPpeRuleRequirementType.Conditional,
+        title: '@workplacesafety-management:hazard-ppe-rules.entities.hazard-ppe-rule.fields.requirement-type.options.conditional',
+    },
+];
+//#endregion
+
+/** Risk rating entity key in the risk-management module. */
+const RISK_MANAGEMENT_RISK_RATING_ENTITY = 'RiskManagement.RiskRating';
+/** Risk matrix cell entity key in the risk-management module. */
+const RISK_MANAGEMENT_RISK_MATRIX_CELL_ENTITY = 'RiskManagement.RiskMatrixCell';
+/** Hazard catalog scope for risk matrix lookup filtering. */
+const RISK_MANAGEMENT_HAZARD_CATALOG_SCOPE = 'risk-management.hazard';
+
+//#region ----   Safety template type options   ----
+const WORKPLACE_SAFETY_TEMPLATE_TYPE_OPTIONS = [
+    {
+        id: 'SWMS',
+        title: '@workplacesafety-management:safety-templates.entities.safety-template.fields.template-type.options.swms',
+    },
+    {
+        id: 'JSA',
+        title: '@workplacesafety-management:safety-templates.entities.safety-template.fields.template-type.options.jsa',
+    },
+    {
+        id: 'Forms',
+        title: '@workplacesafety-management:safety-templates.entities.safety-template.fields.template-type.options.forms',
+    },
+    {
+        id: 'Permits',
+        title: '@workplacesafety-management:safety-templates.entities.safety-template.fields.template-type.options.permits',
+    },
+    {
+        id: 'Plans',
+        title: '@workplacesafety-management:safety-templates.entities.safety-template.fields.template-type.options.plans',
+    },
+];
+//#endregion
+
+//#region ----   Imports   ----
+//#endregion
+//#region ----   Built-in section type IDs   ----
+/** Stable IDs for seeded built-in section types (shared by server mocks and client lookups). */
+const WORKPLACE_SAFETY_BUILT_IN_SECTION_TYPE_IDS = {
+    hazard: 'c1d2e3f4-a5b6-4789-c001-000000000001',
+    hazardRisk: 'c1d2e3f4-a5b6-4789-c001-000000000002',
+    ppe: 'c1d2e3f4-a5b6-4789-c001-000000000003',
+    control: 'c1d2e3f4-a5b6-4789-c001-000000000004',
+    hierarchyLevel: 'c1d2e3f4-a5b6-4789-c001-000000000005',
+    custom: 'c1d2e3f4-a5b6-4789-c001-000000000006',
+    ppeHazards: 'c1d2e3f4-a5b6-4789-c001-000000000007',
+    riskMatrix: 'c1d2e3f4-a5b6-4789-c001-000000000008',
+    hazardRiskPpe: 'c1d2e3f4-a5b6-4789-c001-000000000009',
+    stepTable: 'c1d2e3f4-a5b6-4789-c001-00000000000a',
+};
+const moduleName = RootConfig.module.name;
+/** Maps section type codes to the entity that supplies selectable items. */
+const WORKPLACE_SAFETY_SECTION_TYPE_ENTITY_BY_CODE = {
+    Hazard: `${moduleName}.${RootConfig.entities.hazard.name}`,
+    HazardRisk: `${moduleName}.${RootConfig.entities.hazardRisk.name}`,
+    Ppe: `${moduleName}.${RootConfig.entities.ppeItem.name}`,
+    PpeHazards: `${moduleName}.${RootConfig.entities.hazardPpeRule.name}`,
+    HazardRiskPpe: `${moduleName}.${RootConfig.entities.hazardRiskPpeRule.name}`,
+    Control: `${moduleName}.${RootConfig.entities.controlMeasure.name}`,
+    HierarchyLevel: `${moduleName}.${RootConfig.entities.controlHierarchyLevels.name}`,
+    RiskMatrix: 'RiskManagement.RiskMatrixCell',
+    Custom: undefined,
+    /** Host section for SafetyPlanWorkStep rows (managed by the section builder, not a catalog picker). */
+    StepTable: undefined,
+};
+/** Built-in section types resolved by stable section type id. */
+const WORKPLACE_SAFETY_BUILT_IN_SECTION_TYPE_BY_ID = {
+    [WORKPLACE_SAFETY_BUILT_IN_SECTION_TYPE_IDS.hazard]: {
+        sectionTypeKey: 'Hazard',
+        itemEntityName: WORKPLACE_SAFETY_SECTION_TYPE_ENTITY_BY_CODE.Hazard,
+    },
+    [WORKPLACE_SAFETY_BUILT_IN_SECTION_TYPE_IDS.hazardRisk]: {
+        sectionTypeKey: 'HazardRisk',
+        itemEntityName: WORKPLACE_SAFETY_SECTION_TYPE_ENTITY_BY_CODE.HazardRisk,
+    },
+    [WORKPLACE_SAFETY_BUILT_IN_SECTION_TYPE_IDS.ppe]: {
+        sectionTypeKey: 'Ppe',
+        itemEntityName: WORKPLACE_SAFETY_SECTION_TYPE_ENTITY_BY_CODE.Ppe,
+    },
+    [WORKPLACE_SAFETY_BUILT_IN_SECTION_TYPE_IDS.ppeHazards]: {
+        sectionTypeKey: 'PpeHazards',
+        itemEntityName: WORKPLACE_SAFETY_SECTION_TYPE_ENTITY_BY_CODE.PpeHazards,
+    },
+    [WORKPLACE_SAFETY_BUILT_IN_SECTION_TYPE_IDS.hazardRiskPpe]: {
+        sectionTypeKey: 'HazardRiskPpe',
+        itemEntityName: WORKPLACE_SAFETY_SECTION_TYPE_ENTITY_BY_CODE.HazardRiskPpe,
+    },
+    [WORKPLACE_SAFETY_BUILT_IN_SECTION_TYPE_IDS.control]: {
+        sectionTypeKey: 'Control',
+        itemEntityName: WORKPLACE_SAFETY_SECTION_TYPE_ENTITY_BY_CODE.Control,
+    },
+    [WORKPLACE_SAFETY_BUILT_IN_SECTION_TYPE_IDS.hierarchyLevel]: {
+        sectionTypeKey: 'HierarchyLevel',
+        itemEntityName: WORKPLACE_SAFETY_SECTION_TYPE_ENTITY_BY_CODE.HierarchyLevel,
+    },
+    [WORKPLACE_SAFETY_BUILT_IN_SECTION_TYPE_IDS.riskMatrix]: {
+        sectionTypeKey: 'RiskMatrix',
+        itemEntityName: WORKPLACE_SAFETY_SECTION_TYPE_ENTITY_BY_CODE.RiskMatrix,
+    },
+    [WORKPLACE_SAFETY_BUILT_IN_SECTION_TYPE_IDS.custom]: {
+        sectionTypeKey: 'Custom',
+        itemEntityName: WORKPLACE_SAFETY_SECTION_TYPE_ENTITY_BY_CODE.Custom,
+        isRepeatable: true,
+    },
+    [WORKPLACE_SAFETY_BUILT_IN_SECTION_TYPE_IDS.stepTable]: {
+        sectionTypeKey: 'StepTable',
+        itemEntityName: WORKPLACE_SAFETY_SECTION_TYPE_ENTITY_BY_CODE.StepTable,
+        isRepeatable: true,
+    },
+};
+/** Default entity so the lookup widget mounts before a section type is chosen. */
+const WORKPLACE_SAFETY_SECTION_TYPE_ENTITY_FALLBACK = `${moduleName}.${RootConfig.entities.hazard.name}`;
+//#endregion
+//#region ----   Snapshot helpers   ----
+function resolveSectionTypeKey(sectionTypeId, snapshot) {
+    const fromSnapshot = snapshot?.sectionTypeKey;
+    if (typeof fromSnapshot === 'string' && fromSnapshot.length > 0) {
+        return fromSnapshot;
+    }
+    if (!sectionTypeId) {
+        return undefined;
+    }
+    return WORKPLACE_SAFETY_BUILT_IN_SECTION_TYPE_BY_ID[sectionTypeId]
+        ?.sectionTypeKey;
+}
+function resolveSectionItemEntityName(sectionTypeId, snapshot) {
+    const fromSnapshot = snapshot?.itemEntityName;
+    if (typeof fromSnapshot === 'string' && fromSnapshot.length > 0) {
+        return fromSnapshot;
+    }
+    if (!sectionTypeId) {
+        return undefined;
+    }
+    return WORKPLACE_SAFETY_BUILT_IN_SECTION_TYPE_BY_ID[sectionTypeId]
+        ?.itemEntityName;
+}
+/** Adds runtime lookup metadata (`sectionTypeKey`, `itemEntityName`) from built-in id map. */
+function enrichSectionTypeSnapshot(sectionTypeId, snapshot) {
+    if (!sectionTypeId) {
+        return snapshot;
+    }
+    return {
+        ...snapshot,
+        id: sectionTypeId,
+        sectionTypeKey: resolveSectionTypeKey(sectionTypeId, snapshot),
+        itemEntityName: resolveSectionItemEntityName(sectionTypeId, snapshot),
+        isRepeatable: snapshot?.isRepeatable ??
+            WORKPLACE_SAFETY_BUILT_IN_SECTION_TYPE_BY_ID[sectionTypeId]?.isRepeatable,
+    };
+}
+//#endregion
+//#region ----   Dynamic entity expressions   ----
+function buildSectionTypeEntityExpressionById(sectionTypeIdPath) {
+    const parts = Object.entries(WORKPLACE_SAFETY_BUILT_IN_SECTION_TYPE_BY_ID)
+        .filter(([, meta]) => meta.itemEntityName)
+        .map(([id, meta]) => `context.eval('${sectionTypeIdPath}') === '${id}' ? '${meta.itemEntityName}'`);
+    return `{{ ${parts.join(' : ')} : '${WORKPLACE_SAFETY_SECTION_TYPE_ENTITY_FALLBACK}' }}`;
+}
+function buildSectionTypeEntityExpressionWithSnapshotFallback(sectionTypeIdPath, itemEntityNamePath) {
+    const byId = buildSectionTypeEntityExpressionById(sectionTypeIdPath).slice(3, -2);
+    return `{{ context.eval('${itemEntityNamePath}') || (${byId}) }}`;
+}
+/**
+ * For repeater / nested FormField widgets — `>` walks up to the row where `sectionType` is exposed.
+ */
+const WORKPLACE_SAFETY_SECTION_TYPE_ENTITY_EXPRESSION = buildSectionTypeEntityExpressionWithSnapshotFallback('>sectionType.id', '>sectionType.itemEntityName');
+/**
+ * For flat dialog / dynamic forms — sibling fields share the same context (no parent path).
+ */
+const WORKPLACE_SAFETY_SECTION_TYPE_ENTITY_EXPRESSION_SIBLING = buildSectionTypeEntityExpressionWithSnapshotFallback('sectionType.id', 'sectionType.itemEntityName');
+//#endregion
+
+//#region ----   Imports   ----
+/** Declarative section-type dependencies resolved from prior sections in plan order. */
+const WORKPLACE_SAFETY_SECTION_TYPE_DEPENDENCIES = {
+    HazardRisk: {
+        kind: 'parentFilter',
+        parentSectionTypeKey: 'Hazard',
+        filterField: 'hazardId',
+    },
+    PpeHazards: {
+        kind: 'parentFilter',
+        parentSectionTypeKey: 'Hazard',
+        filterField: 'hazardId',
+    },
+    HazardRiskPpe: {
+        kind: 'parentFilter',
+        parentSectionTypeKey: 'HazardRisk',
+        filterField: 'hazardRiskId',
+    },
+    RiskMatrix: {
+        kind: 'derivedFromParent',
+        parentSectionTypeKey: 'HazardRisk',
+        resolveField: 'riskMatrixId',
+        filterField: 'id',
+    },
+    Control: {
+        kind: 'derivedFromParent',
+        parentSectionTypeKey: 'HazardRisk',
+        resolveField: 'controlMeasureIds',
+        filterField: 'id',
+    },
+};
+/** Section types cleared when upstream hazard selections change. */
+const WORKPLACE_SAFETY_DOWNSTREAM_FROM_HAZARD = [
+    'HazardRisk',
+    'PpeHazards',
+    'HazardRiskPpe',
+    'RiskMatrix',
+    'Control',
+];
+/** Section types cleared when upstream hazard-risk selections change. */
+const WORKPLACE_SAFETY_DOWNSTREAM_FROM_HAZARD_RISK = [
+    'HazardRiskPpe',
+    'RiskMatrix',
+    'Control',
+];
+//#endregion
+//#region ----   Lookup helpers   ----
+const PARENT_HAZARD_IDS_CONTEXT_KEY = 'parentHazardIds';
+const PARENT_HAZARD_RISK_IDS_CONTEXT_KEY = 'parentHazardRiskIds';
+/** Expose paths when a section type is selected (shared by entity repeater and builder dialog). */
+const WORKPLACE_SAFETY_SECTION_TYPE_LOOKUP_EXPOSE = [
+    { source: 'id', target: 'sectionType.id' },
+    { source: 'title', target: 'sectionType.title' },
+    { source: 'code', target: 'sectionType.code' },
+    { source: 'description', target: 'sectionType.description' },
+    { source: 'isRepeatable', target: 'sectionType.isRepeatable' },
+];
+/** Auto-fill section description when section type is selected. */
+const WORKPLACE_SAFETY_SECTION_TYPE_DESCRIPTION_SYNC_TRIGGERS = [
+    {
+        event: "{{ events.context('sectionTypeId') }}",
+        action: "{{ const items = widget.output('selectedItems'); const selectedDescription = Array.isArray(items) ? items[0]?.description : undefined; const d = selectedDescription || context.eval('sectionType.description') || ''; context.set('sectionTypeDescription', d); const descriptionWidget = widget.find('sectionTypeDescription'); if (descriptionWidget) { descriptionWidget.setValue(d); } }}",
+    },
+    {
+        event: "{{ events.context('sectionType.description') }}",
+        action: "{{ const d = context.eval('sectionType.description') || ''; context.set('sectionTypeDescription', d); const descriptionWidget = widget.find('sectionTypeDescription'); if (descriptionWidget) { descriptionWidget.setValue(d); } }}",
+    },
+];
+/** Auto-fill section title when section type is selected. */
+const WORKPLACE_SAFETY_SECTION_TYPE_TITLE_SYNC_TRIGGERS = [
+    {
+        event: "{{ events.context('sectionTypeId') }}",
+        action: "{{ const items = widget.output('selectedItems'); const selectedTitle = Array.isArray(items) ? items[0]?.title : undefined; const t = selectedTitle || context.eval('sectionType.title') || ''; if (t) { context.set('title', t); const titleWidget = widget.find('title'); if (titleWidget) { titleWidget.setValue(t); } } }}",
+    },
+    {
+        event: "{{ events.context('sectionType.title') }}",
+        action: "{{ const t = context.eval('sectionType.title') || ''; if (t) { context.set('title', t); const titleWidget = widget.find('title'); if (titleWidget) { titleWidget.setValue(t); } } }}",
+    },
+];
+/** Shared lookup widget options for section type pickers (builder dialog and entity forms). */
+const WORKPLACE_SAFETY_SECTION_TYPE_LOOKUP_WIDGET_OPTIONS = {
+    look: 'select',
+    allowSearch: true,
+    textField: 'code',
+    textTemplate: '{code} — {description}',
+    valueField: 'id',
+    columns: ['code', 'title', 'description'],
+    expose: WORKPLACE_SAFETY_SECTION_TYPE_LOOKUP_EXPOSE,
+    triggers: [
+        ...WORKPLACE_SAFETY_SECTION_TYPE_TITLE_SYNC_TRIGGERS,
+        ...WORKPLACE_SAFETY_SECTION_TYPE_DESCRIPTION_SYNC_TRIGGERS,
+    ],
+};
+//#endregion
+//#region ----   Resolver API   ----
+function getSectionTypeDependency(sectionTypeKey) {
+    if (!sectionTypeKey) {
+        return undefined;
+    }
+    return WORKPLACE_SAFETY_SECTION_TYPE_DEPENDENCIES[sectionTypeKey];
+}
+function sectionTypeKeyFromSection(section) {
+    const sectionTypeId = section.sectionTypeId || section.sectionType?.id;
+    const key = resolveSectionTypeKey(sectionTypeId, section.sectionType);
+    return key;
+}
+function collectSectionItemIds(section, sectionTypeKey) {
+    if (!section?.items?.length || sectionTypeKeyFromSection(section) !== sectionTypeKey) {
+        return [];
+    }
+    const ids = new Set();
+    for (const item of section.items) {
+        for (const id of item.itemIds ?? []) {
+            if (typeof id === 'string' && id.length > 0) {
+                ids.add(id);
+            }
+        }
+    }
+    return [...ids];
+}
+/** Collects item IDs from sections up to `sectionIndex` whose type matches `parentSectionTypeKey`. */
+function resolveParentItemIds(sections, sectionIndex, parentSectionTypeKey) {
+    const ids = new Set();
+    const lastIndex = Math.min(sectionIndex, sections.length - 1);
+    for (let index = 0; index <= lastIndex; index += 1) {
+        collectSectionItemIds(sections[index], parentSectionTypeKey).forEach((id) => ids.add(id));
+    }
+    return [...ids];
+}
+/** Collects hazard IDs from earlier sections and Hazard rows in the current section. */
+function resolveParentHazardIds(sections, sectionIndex, parentSectionTypeKey = 'Hazard') {
+    return resolveParentItemIds(sections, sectionIndex, parentSectionTypeKey);
+}
+/** Collects hazard-risk IDs from prior HazardRisk sections up to `sectionIndex`. */
+function resolveParentHazardRiskIds(sections, sectionIndex) {
+    return resolveParentItemIds(sections, sectionIndex, 'HazardRisk');
+}
+function parentItemSignature(sections, sectionIndex, parentSectionTypeKey) {
+    return resolveParentItemIds(sections, sectionIndex, parentSectionTypeKey).sort().join('|');
+}
+function shouldClearSectionOnParentChange(section, sectionIndex, changeIndex, parentTypeKey, downstreamTypes) {
+    if (sectionIndex < changeIndex) {
+        return false;
+    }
+    const sectionKey = sectionTypeKeyFromSection(section);
+    if (!sectionKey || !downstreamTypes.includes(sectionKey)) {
+        return false;
+    }
+    if (sectionIndex === changeIndex && sectionKey === parentTypeKey) {
+        return false;
+    }
+    return section.items.some((item) => (item.itemIds?.length ?? 0) > 0);
+}
+function clearSectionItems(section) {
+    return {
+        ...section,
+        items: section.items.map((item) => ({ ...item, itemIds: [], items: [] })),
+    };
+}
+/**
+ * When upstream hazard or hazard-risk selections change, clears item rows in later dependent sections.
+ */
+function clearDependentItemsOnParentChange(previous, next) {
+    if (!next.sections.length) {
+        return next;
+    }
+    let changeIndex = next.sections.length;
+    let hazardChanged = false;
+    let hazardRiskChanged = false;
+    for (let index = 0; index < next.sections.length; index += 1) {
+        const prevHazardSig = parentItemSignature(previous.sections, index, 'Hazard');
+        const nextHazardSig = parentItemSignature(next.sections, index, 'Hazard');
+        if (prevHazardSig !== nextHazardSig) {
+            changeIndex = Math.min(changeIndex, index);
+            hazardChanged = true;
+        }
+        const prevRiskSig = parentItemSignature(previous.sections, index, 'HazardRisk');
+        const nextRiskSig = parentItemSignature(next.sections, index, 'HazardRisk');
+        if (prevRiskSig !== nextRiskSig) {
+            changeIndex = Math.min(changeIndex, index);
+            hazardRiskChanged = true;
+        }
+    }
+    if (changeIndex === next.sections.length) {
+        return next;
+    }
+    return {
+        sections: next.sections.map((section, sectionIndex) => {
+            const clearFromHazard = hazardChanged &&
+                shouldClearSectionOnParentChange(section, sectionIndex, changeIndex, 'Hazard', WORKPLACE_SAFETY_DOWNSTREAM_FROM_HAZARD);
+            const clearFromHazardRisk = hazardRiskChanged &&
+                shouldClearSectionOnParentChange(section, sectionIndex, changeIndex, 'HazardRisk', WORKPLACE_SAFETY_DOWNSTREAM_FROM_HAZARD_RISK);
+            if (!clearFromHazard && !clearFromHazardRisk) {
+                return section;
+            }
+            return clearSectionItems(section);
+        }),
+    };
+}
+function extractRiskMatrixIdsFromHazardRisks(records) {
+    const ids = new Set();
+    for (const record of records) {
+        const id = record['riskMatrixId'];
+        if (typeof id === 'string' && id.length > 0) {
+            ids.add(id);
+        }
+    }
+    return [...ids];
+}
+function extractControlMeasureIdsFromHazardRisks(records) {
+    const ids = new Set();
+    for (const record of records) {
+        const rows = record['controlMeasureIds'];
+        if (!Array.isArray(rows)) {
+            continue;
+        }
+        for (const row of rows) {
+            if (!row || typeof row !== 'object') {
+                continue;
+            }
+            const entry = row;
+            const controlMeasure = entry['controlMeasure'];
+            const id = (typeof entry['controlMeasureId'] === 'string' && entry['controlMeasureId']) ||
+                (typeof controlMeasure?.['id'] === 'string' && controlMeasure['id']) ||
+                undefined;
+            if (id) {
+                ids.add(id);
+            }
+        }
+    }
+    return [...ids];
+}
+function buildInFilter(field, values) {
+    const unique = [...new Set(values.filter((id) => id.length > 0))];
+    if (!unique.length) {
+        return null;
+    }
+    return {
+        field,
+        operator: { type: 'in' },
+        value: unique,
+    };
+}
+/** Filter that matches no records when parent context exists but derived IDs are empty. */
+function buildEmptyResultFilter(field) {
+    return {
+        field,
+        operator: { type: 'in' },
+        value: ['00000000-0000-0000-0000-000000000000'],
+    };
+}
+function resolveSafetyPlanSectionItemFilter(sectionTypeId, parentHazardIds, parentHazardRiskIds = []) {
+    const sectionTypeKey = resolveSectionTypeKey(sectionTypeId);
+    const dependency = getSectionTypeDependency(sectionTypeKey);
+    if (!dependency || dependency.kind !== 'parentFilter') {
+        return null;
+    }
+    const parentIds = dependency.parentSectionTypeKey === 'Hazard' ? parentHazardIds : parentHazardRiskIds;
+    if (!parentIds.length) {
+        return null;
+    }
+    return buildInFilter(dependency.filterField, parentIds);
+}
+async function resolveSafetyPlanSectionItemFilterAsync(sectionTypeId, sections, sectionIndex, loadHazardRisks) {
+    const sectionTypeKey = resolveSectionTypeKey(sectionTypeId);
+    const dependency = getSectionTypeDependency(sectionTypeKey);
+    if (!dependency) {
+        return null;
+    }
+    if (dependency.kind === 'parentFilter') {
+        const parentIds = resolveParentItemIds(sections, sectionIndex, dependency.parentSectionTypeKey);
+        if (!parentIds.length) {
+            return null;
+        }
+        return buildInFilter(dependency.filterField, parentIds);
+    }
+    const parentIds = resolveParentItemIds(sections, sectionIndex, dependency.parentSectionTypeKey);
+    if (!parentIds.length) {
+        return null;
+    }
+    const records = await loadHazardRisks(parentIds);
+    const derivedIds = dependency.resolveField === 'riskMatrixId'
+        ? extractRiskMatrixIdsFromHazardRisks(records)
+        : extractControlMeasureIdsFromHazardRisks(records);
+    if (!derivedIds.length) {
+        return buildEmptyResultFilter(dependency.filterField);
+    }
+    return buildInFilter(dependency.filterField, derivedIds);
+}
+const defaultItemIdsPlaceholderKey = '@workplacesafety-management:safety-plan-sections.entities.safety-plan-section.fields.item-ids.placeholder';
+/** Clears item selection when section type changes in item dialog context. */
+const WORKPLACE_SAFETY_SECTION_ITEM_LOOKUP_CLEAR_ON_SECTION_TYPE_TRIGGERS = [
+    {
+        event: "{{ events.context('sectionType.id') }}",
+        action: "{{ widget.setValue([]); context.set('items', []); }}",
+    },
+    {
+        event: "{{ events.context('sectionTypeId') }}",
+        action: "{{ widget.setValue([]); context.set('items', []); }}",
+    },
+];
+/**
+ * Reloads lookup data after section type is resolved (`sectionType.id`, `itemEntityName`).
+ */
+const WORKPLACE_SAFETY_SECTION_ITEM_LOOKUP_REFRESH_ON_SECTION_TYPE_EXPOSE_TRIGGERS = [
+    {
+        event: "{{ events.context('sectionType.id') }}",
+        action: '{{ widget.refresh(); }}',
+    },
+    {
+        event: "{{ events.context('sectionType.itemEntityName') }}",
+        action: '{{ widget.refresh(); }}',
+    },
+    {
+        event: "{{ events.context('sectionTypeId') }}",
+        action: '{{ widget.refresh(); }}',
+    },
+];
+const WORKPLACE_SAFETY_SECTION_ITEM_LOOKUP_SECTION_TYPE_TRIGGERS = [
+    ...WORKPLACE_SAFETY_SECTION_ITEM_LOOKUP_CLEAR_ON_SECTION_TYPE_TRIGGERS,
+    ...WORKPLACE_SAFETY_SECTION_ITEM_LOOKUP_REFRESH_ON_SECTION_TYPE_EXPOSE_TRIGGERS,
+];
+function isPpeRuleSectionType(sectionTypeId) {
+    return (sectionTypeId === WORKPLACE_SAFETY_BUILT_IN_SECTION_TYPE_IDS.ppeHazards ||
+        sectionTypeId === WORKPLACE_SAFETY_BUILT_IN_SECTION_TYPE_IDS.hazardRiskPpe);
+}
+function buildSectionTypeItemTextFieldExpression(sectionTypeIdPath) {
+    const ppeHazardsId = WORKPLACE_SAFETY_BUILT_IN_SECTION_TYPE_IDS.ppeHazards;
+    const hazardRiskPpeId = WORKPLACE_SAFETY_BUILT_IN_SECTION_TYPE_IDS.hazardRiskPpe;
+    return `{{ [ '${ppeHazardsId}', '${hazardRiskPpeId}' ].includes(context.eval('${sectionTypeIdPath}')) ? 'ppeItem.title' : 'title' }}`;
+}
+function buildSectionTypeItemColumnsExpression(sectionTypeIdPath) {
+    const ppeHazardsId = WORKPLACE_SAFETY_BUILT_IN_SECTION_TYPE_IDS.ppeHazards;
+    const hazardRiskPpeId = WORKPLACE_SAFETY_BUILT_IN_SECTION_TYPE_IDS.hazardRiskPpe;
+    return `{{ [ '${ppeHazardsId}', '${hazardRiskPpeId}' ].includes(context.eval('${sectionTypeIdPath}')) ? ['code', 'ppeItem.title', 'requirementType'] : ['code', 'title'] }}`;
+}
+function buildSectionTypeDependentParentFilter(sectionTypeIdPath, parentIdsContextKey, parentSectionTypeKey) {
+    const dependentSectionTypeIds = Object.entries(WORKPLACE_SAFETY_SECTION_TYPE_DEPENDENCIES)
+        .filter(([, config]) => config.kind === 'parentFilter' && config.parentSectionTypeKey === parentSectionTypeKey)
+        .map(([key]) => {
+        const id = Object.entries(WORKPLACE_SAFETY_BUILT_IN_SECTION_TYPE_BY_ID).find(([, meta]) => meta.sectionTypeKey === key)?.[0];
+        return id ? `'${id}'` : undefined;
+    })
+        .filter((id) => Boolean(id))
+        .join(',');
+    return {
+        field: parentSectionTypeKey === 'Hazard' ? 'hazardId' : 'hazardRiskId',
+        operator: { type: 'in' },
+        value: `{{ [${dependentSectionTypeIds}].includes(context.eval('${sectionTypeIdPath}')) ? ((context.eval('${parentIdsContextKey}') || []).length ? context.eval('${parentIdsContextKey}') : undefined) : undefined }}`,
+    };
+}
+function buildSectionTypeDependentHazardFilter(sectionTypeIdPath, parentHazardIdsContextKey) {
+    return buildSectionTypeDependentParentFilter(sectionTypeIdPath, parentHazardIdsContextKey, 'Hazard');
+}
+const sectionItemLookupExpose = [
+    { source: 'id', target: 'items.{id}' },
+    { source: 'title', target: 'items.{title}' },
+    { source: 'code', target: 'items.{code}' },
+    { source: 'ppeItem.id', target: 'items.{id}' },
+    { source: 'ppeItem.title', target: 'items.{title}' },
+    { source: 'ppeItem.code', target: 'items.{code}' },
+];
+/** Shared item lookup options for builder item dialog (`sectionType.*` in dialog context). */
+function buildSafetyPlanSectionItemLookupOptions(entityExpression, options) {
+    const sectionTypeIdPath = options?.sectionTypeIdPath ?? 'sectionType.id';
+    const lookup = {
+        entity: entityExpression,
+        look: 'lookup',
+        multiple: true,
+        allowSearch: true,
+        textField: buildSectionTypeItemTextFieldExpression(sectionTypeIdPath),
+        columns: buildSectionTypeItemColumnsExpression(sectionTypeIdPath),
+        placeholder: options?.defaultPlaceholderKey ?? defaultItemIdsPlaceholderKey,
+        expose: sectionItemLookupExpose,
+        triggers: WORKPLACE_SAFETY_SECTION_ITEM_LOOKUP_SECTION_TYPE_TRIGGERS,
+    };
+    const filters = [];
+    if (options?.parentHazardIdsContextKey) {
+        filters.push(buildSectionTypeDependentHazardFilter(sectionTypeIdPath, options.parentHazardIdsContextKey));
+    }
+    if (options?.parentHazardRiskIdsContextKey) {
+        filters.push(buildSectionTypeDependentParentFilter(sectionTypeIdPath, options.parentHazardRiskIdsContextKey, 'HazardRisk'));
+    }
+    if (filters.length === 1) {
+        lookup['filter'] = filters[0];
+    }
+    else if (filters.length > 1) {
+        lookup['filter'] = { logic: 'and', filters };
+    }
+    return lookup;
+}
+/** Lookup options with entity data-selector popup UI (`look: 'lookup'`). */
+function buildSafetyPlanSectionItemSelectorOptions(entityExpression, options) {
+    return {
+        ...buildSafetyPlanSectionItemLookupOptions(entityExpression, options),
+        look: 'lookup',
+    };
+}
+function resolveSafetyPlanSectionItemColumns(sectionTypeId) {
+    if (sectionTypeId === WORKPLACE_SAFETY_BUILT_IN_SECTION_TYPE_IDS.ppeHazards) {
+        return ['code', 'ppeItem.title', 'requirementType'];
+    }
+    if (sectionTypeId === WORKPLACE_SAFETY_BUILT_IN_SECTION_TYPE_IDS.hazardRiskPpe) {
+        return ['code', 'hazardRisk.title', 'ppeItem.title', 'requirementType'];
+    }
+    if (sectionTypeId === WORKPLACE_SAFETY_BUILT_IN_SECTION_TYPE_IDS.riskMatrix) {
+        return ['code', 'title'];
+    }
+    return ['code', 'title'];
+}
+function resolveSafetyPlanSectionItemEntityKey(sectionTypeId, sectionType) {
+    return resolveSectionItemEntityName(sectionTypeId, sectionType);
+}
+function mapSafetyPlanSectionSelectedItems(sectionTypeId, selectedItems) {
+    const isPpeHazards = sectionTypeId === WORKPLACE_SAFETY_BUILT_IN_SECTION_TYPE_IDS.ppeHazards;
+    const isHazardRiskPpe = sectionTypeId === WORKPLACE_SAFETY_BUILT_IN_SECTION_TYPE_IDS.hazardRiskPpe;
+    return selectedItems
+        .map((item) => {
+        if (isPpeHazards || isHazardRiskPpe) {
+            const ppeItem = item['ppeItem'];
+            const id = String(ppeItem?.['id'] ?? item['id'] ?? '');
+            return {
+                id,
+                title: typeof ppeItem?.['title'] === 'string' ? ppeItem['title'] : undefined,
+                code: typeof ppeItem?.['code'] === 'string' ? ppeItem['code'] : undefined,
+            };
+        }
+        return {
+            id: String(item['id'] ?? ''),
+            title: typeof item['title'] === 'string' ? item['title'] : undefined,
+            code: typeof item['code'] === 'string' ? item['code'] : undefined,
+        };
+    })
+        .filter((item) => item.id.length > 0);
+}
+function dedupeSafetyPlanSectionItemSelection(item) {
+    const seen = new Set();
+    const itemIds = [];
+    const items = [];
+    for (let index = 0; index < (item.itemIds?.length ?? 0); index += 1) {
+        const id = item.itemIds?.[index];
+        if (typeof id !== 'string' || !id || seen.has(id)) {
+            continue;
+        }
+        seen.add(id);
+        itemIds.push(id);
+        const snapshot = item.items?.[index];
+        items.push(snapshot?.id === id ? snapshot : { id });
+    }
+    return { ...item, itemIds, items };
+}
+function isPpeRuleSectionTypeId(sectionTypeId) {
+    return isPpeRuleSectionType(sectionTypeId);
+}
+//#endregion
+
+/** Component key for the safety plan Sections page tab. Register via AXP_PAGE_COMPONENT_PROVIDER. */
+const SAFETY_PLAN_SECTIONS_PAGE_COMPONENT_KEY = 'safety-plan-sections-page';
+
+//#region ----   Safety plan section builder value types   ----
+//#endregion
+
+/**
+ * Shared helpers for Safety Plan Section uniqueness (section type per plan).
+ * Leaf module — imports only other contract leaves (no client/server layers).
+ */
+//#region ---- Constants ----
+const SAFETY_PLAN_SECTION_DUPLICATE_SECTION_TYPE_MESSAGE_KEY = '@workplacesafety-management:safety-plan-sections.messages.duplicate-section-type';
+/** Stable API / middleware error code for duplicate section type in a plan. */
+const SAFETY_PLAN_SECTION_DUPLICATE_SECTION_TYPE_CODE = 'SAFETY_PLAN_SECTION_DUPLICATE_SECTION_TYPE';
+//#endregion
+//#region ---- Helpers ----
+function resolveRefId$1(raw) {
+    if (typeof raw === 'string' && raw.trim().length > 0) {
+        return raw.trim();
+    }
+    if (typeof raw === 'number' && Number.isFinite(raw)) {
+        return String(raw);
+    }
+    if (raw && typeof raw === 'object') {
+        const id = raw.id;
+        if (typeof id === 'string' && id.trim().length > 0) {
+            return id.trim();
+        }
+    }
+    return '';
+}
+/** Resolves the section type id from a plan section identity or nested snapshot. */
+function resolveSafetyPlanSectionTypeId(section) {
+    return resolveRefId$1(section.sectionTypeId) || resolveRefId$1(section.sectionType);
+}
+/**
+ * True when this section type may appear more than once in a Safety Plan.
+ * Checks (in order): snapshot flag, explicit allow-list, built-in section type meta.
+ */
+function isSafetyPlanSectionTypeRepeatable(sectionTypeId, options) {
+    const id = resolveRefId$1(sectionTypeId);
+    if (!id) {
+        return false;
+    }
+    if (options?.sectionType?.isRepeatable === true) {
+        return true;
+    }
+    const allowList = new Set((options?.repeatableSectionTypeIds ?? []).map((entry) => resolveRefId$1(entry)).filter(Boolean));
+    if (allowList.has(id)) {
+        return true;
+    }
+    return WORKPLACE_SAFETY_BUILT_IN_SECTION_TYPE_BY_ID[id]?.isRepeatable === true;
+}
+/** Built-in section type ids that are always treated as repeatable. */
+function collectBuiltInRepeatableSectionTypeIds() {
+    return Object.entries(WORKPLACE_SAFETY_BUILT_IN_SECTION_TYPE_BY_ID)
+        .filter(([, meta]) => meta.isRepeatable === true)
+        .map(([id]) => id);
+}
+//#endregion
+//#region ---- Validation ----
+/**
+ * Returns the first duplicate non-repeatable `sectionTypeId` in the list, or `null`
+ * when all non-repeatable types are unique. Empty / missing section type ids are ignored.
+ * Repeatable section types are allowed to appear more than once.
+ */
+function findDuplicateSafetyPlanSectionTypeId(sections, options) {
+    const excludeId = options?.excludeSectionId?.trim() || '';
+    const seen = new Set();
+    for (const section of sections) {
+        const id = resolveRefId$1(section.id);
+        if (excludeId && id === excludeId) {
+            continue;
+        }
+        const sectionTypeId = resolveSafetyPlanSectionTypeId(section);
+        if (!sectionTypeId ||
+            isSafetyPlanSectionTypeRepeatable(sectionTypeId, {
+                repeatableSectionTypeIds: options?.repeatableSectionTypeIds,
+                sectionType: section.sectionType,
+            })) {
+            continue;
+        }
+        if (seen.has(sectionTypeId)) {
+            return sectionTypeId;
+        }
+        seen.add(sectionTypeId);
+    }
+    return null;
+}
+/**
+ * True when `sectionTypeId` already appears on another section in the collection
+ * and the type is not repeatable.
+ */
+function safetyPlanSectionTypeAlreadyExists(sections, sectionTypeId, options) {
+    const target = resolveRefId$1(sectionTypeId);
+    if (!target) {
+        return false;
+    }
+    if (isSafetyPlanSectionTypeRepeatable(target, {
+        repeatableSectionTypeIds: options?.repeatableSectionTypeIds,
+        sectionType: options?.sectionType,
+    })) {
+        return false;
+    }
+    const excludeId = options?.excludeSectionId?.trim() || '';
+    return sections.some((section) => {
+        const id = resolveRefId$1(section.id);
+        if (excludeId && id === excludeId) {
+            return false;
+        }
+        return resolveSafetyPlanSectionTypeId(section) === target;
+    });
+}
+//#endregion
+
+//#region ----   Imports   ----
+function resolveSectionTypeTitle(sectionTypeId, sectionType) {
+    if (typeof sectionType?.title === 'string' && sectionType.title.trim()) {
+        return sectionType.title.trim();
+    }
+    if (typeof sectionType?.code === 'string' && sectionType.code.trim()) {
+        return sectionType.code.trim();
+    }
+    return sectionTypeId;
+}
+/** True when a type-section row is marked as the plan-type default template. */
+function isSafetyPlanTypeSectionDefault(row) {
+    const value = row?.isDefault;
+    return value === true || value === 1 || value === 'true';
+}
+/** Extracts a stable entity id from a raw lookup / context value. */
+function resolveEntityRefId(raw) {
+    if (typeof raw === 'string' && raw.trim().length > 0) {
+        return raw.trim();
+    }
+    if (typeof raw === 'number' && Number.isFinite(raw)) {
+        return String(raw);
+    }
+    if (raw && typeof raw === 'object') {
+        const id = raw.id;
+        if (typeof id === 'string' && id.trim().length > 0) {
+            return id.trim();
+        }
+    }
+    return null;
+}
+function resolveSectionTypeId(typeRow) {
+    if (!typeRow) {
+        return '';
+    }
+    return (resolveEntityRefId(typeRow.sectionTypeId) ??
+        resolveEntityRefId(typeRow.sectionType) ??
+        resolveEntityRefId(typeRow.sectionType?.id) ??
+        '');
+}
+//#endregion
+//#region ----   Build from type sections   ----
+let structureIdSeq = 0;
+function nextStructureId(prefix) {
+    structureIdSeq += 1;
+    const rand = typeof crypto !== 'undefined' && 'randomUUID' in crypto
+        ? crypto.randomUUID()
+        : `00000000-0000-4000-8000-${String(structureIdSeq).padStart(12, '0')}`;
+    return prefix ? `${prefix}-${rand}` : rand;
+}
+/**
+ * Builds an empty editable section structure from SafetyPlanTypeSection rows for one plan type.
+ *
+ * Uses `isDefault` rows when present; otherwise falls back to all active rows for that type
+ * (so a mis-flagged template still produces a structure). One plan section per `sectionTypeIds`
+ * entry, titled from the Section Type, ordered by type-section `sortOrder` then repeater order.
+ */
+function buildSectionStructureFromTypeSections(typeSections, options) {
+    const createId = options?.createId ?? (() => nextStructureId(''));
+    const active = typeSections
+        .filter((row) => row && row.isArchived !== true)
+        .slice()
+        .sort((a, b) => (a.sortOrder ?? 0) - (b.sortOrder ?? 0) || String(a.title ?? '').localeCompare(String(b.title ?? '')));
+    const defaults = active.filter((row) => isSafetyPlanTypeSectionDefault(row));
+    const sourceRows = defaults.length > 0 ? defaults : active;
+    const sections = [];
+    const seenSourceTypePairs = new Set();
+    let sortOrder = 1;
+    for (const typeSection of sourceRows) {
+        const typeRows = Array.isArray(typeSection.sectionTypeIds) ? typeSection.sectionTypeIds : [];
+        if (!typeRows.length) {
+            continue;
+        }
+        for (const typeRow of typeRows) {
+            const sectionTypeId = resolveSectionTypeId(typeRow);
+            if (!sectionTypeId) {
+                continue;
+            }
+            // One plan section per (type-section source, section type) — prevents
+            // accidental double expansion when the same type is listed twice.
+            const sourceId = typeof typeSection.id === 'string' ? typeSection.id : '';
+            const pairKey = sourceId ? `${sourceId}|${sectionTypeId}` : sectionTypeId;
+            if (seenSourceTypePairs.has(pairKey)) {
+                continue;
+            }
+            seenSourceTypePairs.add(pairKey);
+            const sectionType = typeRow.sectionType
+                ? { id: sectionTypeId, title: typeRow.sectionType.title, code: typeRow.sectionType.code }
+                : { id: sectionTypeId };
+            const sectionId = createId();
+            sections.push({
+                id: sectionId,
+                sectionTypeId,
+                sectionType,
+                title: resolveSectionTypeTitle(sectionTypeId, sectionType),
+                description: '',
+                sourceSafetyPlanTypeSectionId: typeSection.id,
+                sortOrder: sortOrder++,
+                required: isSafetyPlanTypeSectionDefault(typeSection) || defaults.length === 0,
+                items: [
+                    {
+                        id: `${sectionId}__item_1`,
+                        itemIds: [],
+                        items: [],
+                    },
+                ],
+            });
+        }
+    }
+    return { sections };
+}
+/**
+ * Removes accidental duplicate plan sections.
+ * Non-repeatable section types are kept once (first wins); repeatable types may appear more than once.
+ * Reassigns contiguous 1-based `sortOrder` to preserve display order.
+ */
+function dedupeSafetyPlanSectionStructure(structure, options) {
+    const sections = Array.isArray(structure?.sections)
+        ? structure.sections
+        : [];
+    const seenSectionTypeIds = new Set();
+    const seenSourceTypePairs = new Set();
+    const deduped = [];
+    for (const section of sections) {
+        const sectionTypeId = resolveEntityRefId(section.sectionTypeId) ?? String(section.sectionTypeId ?? '').trim();
+        if (!sectionTypeId) {
+            continue;
+        }
+        const sourceId = String(section.sourceSafetyPlanTypeSectionId ?? '').trim();
+        const sourcePairKey = sourceId ? `${sourceId}|${sectionTypeId}` : '';
+        // Same type-section source + section type must never appear twice (double materialization).
+        if (sourcePairKey && seenSourceTypePairs.has(sourcePairKey)) {
+            continue;
+        }
+        const sectionType = section.sectionType;
+        const isRepeatable = isSafetyPlanSectionTypeRepeatable(sectionTypeId, {
+            repeatableSectionTypeIds: options?.repeatableSectionTypeIds,
+            sectionType,
+        });
+        if (!isRepeatable && seenSectionTypeIds.has(sectionTypeId)) {
+            continue;
+        }
+        if (sourcePairKey) {
+            seenSourceTypePairs.add(sourcePairKey);
+        }
+        seenSectionTypeIds.add(sectionTypeId);
+        deduped.push(section);
+    }
+    return {
+        ...structure,
+        sections: deduped.map((section, index) => ({
+            ...section,
+            sortOrder: index + 1,
+        })),
+    };
+}
+function collectAllowedSectionTypeIds(typeSections) {
+    const ids = new Set();
+    for (const typeSection of typeSections) {
+        if (typeSection.isArchived === true) {
+            continue;
+        }
+        for (const row of typeSection.sectionTypeIds ?? []) {
+            const id = resolveSectionTypeId(row);
+            if (id) {
+                ids.add(id);
+            }
+        }
+    }
+    return [...ids];
+}
+function collectRequiredSourceTypeSectionIds(typeSections) {
+    return typeSections
+        .filter((row) => row.isArchived !== true && isSafetyPlanTypeSectionDefault(row))
+        .map((row) => row.id)
+        .filter((id) => typeof id === 'string' && id.length > 0);
+}
+/**
+ * Validates that a plan-type section template does not list the same
+ * non-repeatable section type more than once (across rows and within a single row's repeater).
+ */
+function validateSafetyPlanTypeSectionTemplate(typeSections, repeatableSectionTypeIds = []) {
+    const seen = new Map();
+    const issues = [];
+    for (const typeSection of typeSections) {
+        if (typeSection.isArchived === true) {
+            continue;
+        }
+        for (const row of typeSection.sectionTypeIds ?? []) {
+            const sectionTypeId = resolveSectionTypeId(row);
+            if (!sectionTypeId ||
+                isSafetyPlanSectionTypeRepeatable(sectionTypeId, {
+                    repeatableSectionTypeIds,
+                    sectionType: row.sectionType,
+                })) {
+                continue;
+            }
+            const sectionTypeTitle = resolveSectionTypeTitle(sectionTypeId, row.sectionType);
+            if (seen.has(sectionTypeId)) {
+                issues.push({
+                    code: 'INVALID_TYPE_SECTION_TEMPLATE',
+                    messageKey: '@workplacesafety-management:safety-plans.messages.section-structure.invalid-type-template-duplicate',
+                    details: {
+                        sectionTypeId,
+                        sectionTypeTitle,
+                        sourceSafetyPlanTypeSectionId: typeSection.id,
+                        previousSourceSafetyPlanTypeSectionId: seen.get(sectionTypeId)?.sourceSafetyPlanTypeSectionId,
+                    },
+                });
+                continue;
+            }
+            seen.set(sectionTypeId, {
+                title: sectionTypeTitle,
+                sourceSafetyPlanTypeSectionId: typeSection.id,
+            });
+        }
+    }
+    return issues;
+}
+//#endregion
+//#region ----   Validation   ----
+function validateSafetyPlanSectionStructure(structure, context) {
+    const sections = Array.isArray(structure?.sections) ? structure.sections : [];
+    const issues = [];
+    const presentSourceIds = new Set(sections
+        .map((s) => s.sourceSafetyPlanTypeSectionId)
+        .filter((id) => typeof id === 'string' && id.length > 0));
+    for (const requiredSourceId of context.requiredSourceTypeSectionIds) {
+        if (!presentSourceIds.has(requiredSourceId)) {
+            issues.push({
+                code: 'REQUIRED_SECTION_MISSING',
+                messageKey: '@workplacesafety-management:safety-plans.messages.section-structure.required-section-missing',
+                details: { sourceSafetyPlanTypeSectionId: requiredSourceId },
+            });
+        }
+    }
+    const allowed = new Set(context.allowedSectionTypeIds);
+    const seenSectionTypeIds = new Set();
+    const sortOrders = [];
+    for (const section of sections) {
+        const sectionTypeId = resolveEntityRefId(section.sectionTypeId) ??
+            String(section.sectionTypeId ?? '').trim();
+        if (!sectionTypeId) {
+            continue;
+        }
+        const sectionType = section
+            .sectionType;
+        const sectionTypeTitle = resolveSectionTypeTitle(sectionTypeId, sectionType);
+        if (allowed.size > 0 && !allowed.has(sectionTypeId)) {
+            issues.push({
+                code: 'SECTION_TYPE_NOT_ALLOWED',
+                messageKey: '@workplacesafety-management:safety-plans.messages.section-structure.section-type-not-allowed',
+                details: { sectionTypeId, sectionTypeTitle, sectionId: section.id },
+            });
+        }
+        const isRepeatable = isSafetyPlanSectionTypeRepeatable(sectionTypeId, {
+            repeatableSectionTypeIds: context.repeatableSectionTypeIds,
+            sectionType,
+        });
+        if (!isRepeatable && seenSectionTypeIds.has(sectionTypeId)) {
+            issues.push({
+                code: 'DUPLICATE_NON_REPEATABLE_SECTION',
+                messageKey: '@workplacesafety-management:safety-plans.messages.section-structure.duplicate-non-repeatable',
+                details: { sectionTypeId, sectionTypeTitle, sectionId: section.id },
+            });
+        }
+        seenSectionTypeIds.add(sectionTypeId);
+        const sortOrder = section.sortOrder;
+        if (typeof sortOrder === 'number' && Number.isFinite(sortOrder)) {
+            sortOrders.push(sortOrder);
+        }
+    }
+    if (sortOrders.length !== sections.length) {
+        issues.push({
+            code: 'INVALID_SORT_ORDER',
+            messageKey: '@workplacesafety-management:safety-plans.messages.section-structure.invalid-sort-order',
+        });
+    }
+    else {
+        const unique = new Set(sortOrders);
+        if (unique.size !== sortOrders.length) {
+            issues.push({
+                code: 'INVALID_SORT_ORDER',
+                messageKey: '@workplacesafety-management:safety-plans.messages.section-structure.invalid-sort-order',
+                details: { reason: 'duplicate' },
+            });
+        }
+    }
+    return issues;
+}
+function toBuilderValueFromStructure(structure) {
+    return {
+        sections: structure.sections.map((section) => ({
+            id: section.id,
+            sectionTypeId: section.sectionTypeId,
+            sectionType: section.sectionType,
+            title: section.title,
+            description: section.description ?? '',
+            safetyPlanId: section.safetyPlanId,
+            code: section.code,
+            sourceSafetyPlanTypeSectionId: section.sourceSafetyPlanTypeSectionId,
+            sortOrder: section.sortOrder,
+            required: section.required,
+            items: section.items.map((item) => ({
+                id: item.id,
+                itemIds: [...(item.itemIds ?? [])],
+                items: item.items ? [...item.items] : [],
+            })),
+        })),
+    };
+}
+//#endregion
+
+//#region ----   Imports   ----
+//#endregion
+//#region ----   Local helpers   ----
+function nextId() {
+    return typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function'
+        ? crypto.randomUUID()
+        : `tmp-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+}
+function resolveRefId(value) {
+    if (typeof value === 'string') {
+        return value.trim();
+    }
+    if (value != null && typeof value === 'object' && 'id' in value) {
+        const id = value.id;
+        return typeof id === 'string' ? id.trim() : '';
+    }
+    return '';
+}
+//#endregion
+//#region ----   Detection   ----
+/** True when the section type is the Step Table host for SafetyPlanWorkStep rows. */
+function isStepTableSectionType(sectionTypeId, snapshot) {
+    if (sectionTypeId === WORKPLACE_SAFETY_BUILT_IN_SECTION_TYPE_IDS.stepTable) {
+        return true;
+    }
+    return resolveSectionTypeKey(sectionTypeId, snapshot) === 'StepTable';
+}
+//#endregion
+//#region ----   Column helpers   ----
+/** Stable key used on cells for this column (`sectionTypeId`). */
+function stepTableColumnKey(column) {
+    return resolveRefId(column.sectionTypeId) || resolveRefId(column.sectionType);
+}
+function stepTableColumnTitle(column) {
+    const explicit = typeof column.title === 'string' ? column.title.trim() : '';
+    if (explicit) {
+        return explicit;
+    }
+    const fromType = (typeof column.sectionType?.title === 'string' && column.sectionType.title.trim()) ||
+        (typeof column.sectionType?.code === 'string' && column.sectionType.code.trim()) ||
+        '';
+    return fromType || 'Column';
+}
+/** Resolves the catalog entity for a column from its SectionType mapping. */
+function resolveStepTableColumnLookupEntity(column) {
+    const sectionTypeId = stepTableColumnKey(column);
+    return resolveSectionItemEntityName(sectionTypeId, enrichSectionTypeSnapshot(sectionTypeId, column.sectionType));
+}
+/** Multi-select when the mapped section type typically holds many items. */
+function isStepTableColumnMultiLookup(column) {
+    const key = resolveSectionTypeKey(stepTableColumnKey(column), enrichSectionTypeSnapshot(stepTableColumnKey(column), column.sectionType));
+    return key === 'Control' || key === 'Ppe' || key === 'PpeHazards' || key === 'HazardRiskPpe';
+}
+function sortStepTableColumns(columns) {
+    return [...columns].sort((a, b) => (a.sortOrder ?? 0) - (b.sortOrder ?? 0) ||
+        stepTableColumnKey(a).localeCompare(stepTableColumnKey(b)));
+}
+function createEmptyStepTableRow(columns, sortOrder = 1) {
+    const ordered = sortStepTableColumns(columns);
+    return {
+        id: nextId(),
+        sortOrder,
+        cells: ordered.map((column) => createEmptyStepTableCell(stepTableColumnKey(column))),
+    };
+}
+function createEmptyStepTableCell(columnKey) {
+    return { columnKey, refIds: [], refs: [] };
+}
+/** Builds a new work-step payload from a WorkStepType (columns snapshot + one empty row). */
+function buildWorkStepContentFromType(type) {
+    const columns = normalizeStepTableColumns(type.columns ?? []);
+    return {
+        columns,
+        rows: columns.length > 0 ? [createEmptyStepTableRow(columns, 1)] : [],
+    };
+}
+function normalizeStepTableColumns(columns) {
+    if (!Array.isArray(columns)) {
+        return [];
+    }
+    return sortStepTableColumns(columns
+        .filter((column) => column != null && typeof column === 'object')
+        .map((column, index) => {
+        const sectionTypeId = resolveRefId(column.sectionTypeId) || resolveRefId(column.sectionType);
+        const sectionType = enrichSectionTypeSnapshot(sectionTypeId, column.sectionType);
+        const title = typeof column.title === 'string' && column.title.trim()
+            ? column.title.trim()
+            : sectionType?.title;
+        return {
+            sectionTypeId,
+            sectionType,
+            title,
+            sortOrder: typeof column.sortOrder === 'number' ? column.sortOrder : index + 1,
+            required: column.required === true,
+        };
+    })
+        .filter((column) => column.sectionTypeId.length > 0));
+}
+function normalizeStepTableRows(rows, columns) {
+    if (!Array.isArray(rows)) {
+        return [];
+    }
+    const columnKeys = new Set(columns.map((column) => stepTableColumnKey(column)).filter(Boolean));
+    return [...rows]
+        .filter((row) => row != null && typeof row === 'object')
+        .map((row, index) => {
+        const id = typeof row.id === 'string' && row.id.trim() ? row.id.trim() : nextId();
+        const cellsByKey = new Map();
+        for (const cell of Array.isArray(row.cells) ? row.cells : []) {
+            if (!cell || typeof cell !== 'object' || typeof cell.columnKey !== 'string') {
+                continue;
+            }
+            cellsByKey.set(cell.columnKey, {
+                columnKey: cell.columnKey,
+                textValue: typeof cell.textValue === 'string' ? cell.textValue : undefined,
+                numberValue: typeof cell.numberValue === 'number' ? cell.numberValue : undefined,
+                refIds: Array.isArray(cell.refIds)
+                    ? cell.refIds.filter((id) => typeof id === 'string' && id.length > 0)
+                    : [],
+                refs: Array.isArray(cell.refs)
+                    ? cell.refs
+                        .filter((ref) => ref != null &&
+                        typeof ref === 'object' &&
+                        typeof ref.id === 'string')
+                        .map((ref) => ({
+                        id: ref.id,
+                        title: typeof ref.title === 'string' ? ref.title : undefined,
+                        code: typeof ref.code === 'string' ? ref.code : undefined,
+                    }))
+                    : [],
+            });
+        }
+        const cells = columns.map((column) => {
+            const key = stepTableColumnKey(column);
+            return cellsByKey.get(key) ?? createEmptyStepTableCell(key);
+        });
+        for (const [key, cell] of cellsByKey) {
+            if (!columnKeys.has(key)) {
+                cells.push(cell);
+            }
+        }
+        return {
+            id,
+            sortOrder: typeof row.sortOrder === 'number' ? row.sortOrder : index + 1,
+            cells,
+        };
+    })
+        .sort((a, b) => a.sortOrder - b.sortOrder);
+}
+function toWorkStepBuilderPayload(entity) {
+    const columns = normalizeStepTableColumns(entity.columns);
+    return {
+        id: entity.id,
+        code: entity.code,
+        workStepTypeId: entity.workStepTypeId,
+        workStepType: entity.workStepType,
+        title: entity.title,
+        columns,
+        cells: normalizeStepTableRows([{ id: entity.id, sortOrder: entity.sortOrder ?? 1, cells: entity.cells ?? [] }], columns)[0]?.cells ?? entity.cells ?? [],
+        sortOrder: entity.sortOrder,
+    };
+}
+//#endregion
+
+//#region ----   Built-in work step type IDs   ----
+/** Stable IDs for seeded Work Step Types (shared by server mocks and client). */
+const WORKPLACE_SAFETY_BUILT_IN_WORK_STEP_TYPE_IDS = {
+    generalTask: 'c1d2e5f4-a5b6-4789-d001-000000000001',
+    sitePreparation: 'c1d2e5f4-a5b6-4789-d001-000000000002',
+    performWork: 'c1d2e5f4-a5b6-4789-d001-000000000003',
+};
+//#endregion
+
+//#region ----   Imports   ----
+//#endregion
+
+//#region ----   Imports   ----
+//#endregion
+
+//#region ----   Imports   ----
+//#endregion
+//#region ----   Enums   ----
+var AXMHazardRegisterContextType;
+(function (AXMHazardRegisterContextType) {
+    AXMHazardRegisterContextType["Asset"] = "asset";
+    AXMHazardRegisterContextType["Site"] = "site";
+    AXMHazardRegisterContextType["WorkOrder"] = "work-order";
+    AXMHazardRegisterContextType["Project"] = "project";
+})(AXMHazardRegisterContextType || (AXMHazardRegisterContextType = {}));
+//#endregion
+
+//#region ----   Imports   ----
+//#endregion
+
+//#region ----   Imports   ----
+//#endregion
+
+//#endregion
+
+//#region ----   Imports   ----
+//#endregion
+
+//#region ----   Imports   ----
+//#endregion
+
+//#region ----   Imports   ----
+//#endregion
+
+//#region ----   Imports   ----
+//#endregion
+
+//#region ----   Imports   ----
+//#endregion
+
+//#region ----   Imports   ----
+//#endregion
+
+//#region ----   Imports   ----
+//#endregion
+
+//#region ----   Imports   ----
+//#endregion
+
+//#region ---- Contracts barrel ----
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { AXMHazardPpeRuleRequirementType, AXMHazardRegisterContextType, AXMWorkplaceSafetyManagementCommandKeys, AXMWorkplaceSafetyManagementMenuKeys, AXMWorkplaceSafetyManagementPermissionKeys, AXPSafetyRiskPermissionKeys, PARENT_HAZARD_IDS_CONTEXT_KEY, PARENT_HAZARD_RISK_IDS_CONTEXT_KEY, RISK_MANAGEMENT_HAZARD_CATALOG_SCOPE, RISK_MANAGEMENT_RISK_MATRIX_CELL_ENTITY, RISK_MANAGEMENT_RISK_RATING_ENTITY, RootConfig, SAFETY_PLAN_SECTIONS_PAGE_COMPONENT_KEY, SAFETY_PLAN_SECTION_DUPLICATE_SECTION_TYPE_CODE, SAFETY_PLAN_SECTION_DUPLICATE_SECTION_TYPE_MESSAGE_KEY, WORKPLACE_SAFETY_BUILT_IN_SECTION_TYPE_BY_ID, WORKPLACE_SAFETY_BUILT_IN_SECTION_TYPE_IDS, WORKPLACE_SAFETY_BUILT_IN_WORK_STEP_TYPE_IDS, WORKPLACE_SAFETY_DOWNSTREAM_FROM_HAZARD, WORKPLACE_SAFETY_DOWNSTREAM_FROM_HAZARD_RISK, WORKPLACE_SAFETY_GHS_SYMBOL_OPTIONS, WORKPLACE_SAFETY_HAZARD_PPE_RULE_REQUIREMENT_TYPE_OPTIONS, WORKPLACE_SAFETY_SECTION_ITEM_LOOKUP_CLEAR_ON_SECTION_TYPE_TRIGGERS, WORKPLACE_SAFETY_SECTION_ITEM_LOOKUP_REFRESH_ON_SECTION_TYPE_EXPOSE_TRIGGERS, WORKPLACE_SAFETY_SECTION_ITEM_LOOKUP_SECTION_TYPE_TRIGGERS, WORKPLACE_SAFETY_SECTION_TYPE_DEPENDENCIES, WORKPLACE_SAFETY_SECTION_TYPE_DESCRIPTION_SYNC_TRIGGERS, WORKPLACE_SAFETY_SECTION_TYPE_ENTITY_BY_CODE, WORKPLACE_SAFETY_SECTION_TYPE_ENTITY_EXPRESSION, WORKPLACE_SAFETY_SECTION_TYPE_ENTITY_EXPRESSION_SIBLING, WORKPLACE_SAFETY_SECTION_TYPE_ENTITY_FALLBACK, WORKPLACE_SAFETY_SECTION_TYPE_LOOKUP_EXPOSE, WORKPLACE_SAFETY_SECTION_TYPE_LOOKUP_WIDGET_OPTIONS, WORKPLACE_SAFETY_SECTION_TYPE_TITLE_SYNC_TRIGGERS, WORKPLACE_SAFETY_TEMPLATE_TYPE_OPTIONS, buildSafetyPlanSectionItemLookupOptions, buildSafetyPlanSectionItemSelectorOptions, buildSectionStructureFromTypeSections, buildWorkStepContentFromType, clearDependentItemsOnParentChange, collectAllowedSectionTypeIds, collectBuiltInRepeatableSectionTypeIds, collectRequiredSourceTypeSectionIds, createEmptyStepTableCell, createEmptyStepTableRow, dedupeSafetyPlanSectionItemSelection, dedupeSafetyPlanSectionStructure, enrichSectionTypeSnapshot, extractControlMeasureIdsFromHazardRisks, extractRiskMatrixIdsFromHazardRisks, findDuplicateSafetyPlanSectionTypeId, getSectionTypeDependency, isPpeRuleSectionTypeId, isSafetyPlanSectionTypeRepeatable, isSafetyPlanTypeSectionDefault, isStepTableColumnMultiLookup, isStepTableSectionType, mapSafetyPlanSectionSelectedItems, normalizeStepTableColumns, normalizeStepTableRows, resolveEntityRefId, resolveParentHazardIds, resolveParentHazardRiskIds, resolveParentItemIds, resolveSafetyPlanSectionItemColumns, resolveSafetyPlanSectionItemEntityKey, resolveSafetyPlanSectionItemFilter, resolveSafetyPlanSectionItemFilterAsync, resolveSafetyPlanSectionTypeId, resolveSectionItemEntityName, resolveSectionTypeKey, resolveStepTableColumnLookupEntity, safetyPlanSectionTypeAlreadyExists, sectionTypeKeyFromSection, sortStepTableColumns, stepTableColumnKey, stepTableColumnTitle, toBuilderValueFromStructure, toWorkStepBuilderPayload, validateSafetyPlanSectionStructure, validateSafetyPlanTypeSectionTemplate };
+//# sourceMappingURL=acorex-platform-module-workplacesafety-management-client-contracts.mjs.map